Skip to main content

rustjava_runtime/classes/java/util/
timer_thread.rs

1use alloc::vec;
2
3use jvm::{Array, ClassInstanceRef, JavaError, Jvm, Result};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{
8    RuntimeClassProto, RuntimeContext,
9    classes::java::util::{TimerTask, TimerTaskQueue},
10};
11
12enum WorkerAction {
13    Continue,
14    Run(ClassInstanceRef<TimerTask>),
15    Stop,
16}
17
18// class java.util.Timer$TimerThread
19pub struct TimerThread;
20
21impl TimerThread {
22    pub fn as_proto() -> RuntimeClassProto {
23        RuntimeClassProto {
24            name: "java/util/Timer$TimerThread",
25            parent_class: Some("java/lang/Thread"),
26            interfaces: vec![],
27            methods: vec![
28                JavaMethodProto::new("<init>", "(Ljava/util/Timer$TaskQueue;)V", Self::init, MethodAccessFlags::empty()),
29                JavaMethodProto::new("run", "()V", Self::run, MethodAccessFlags::PUBLIC),
30            ],
31            fields: vec![
32                JavaFieldProto::new("queue", "Ljava/util/Timer$TaskQueue;", FieldAccessFlags::PRIVATE),
33                JavaFieldProto::new("newTasksMayBeScheduled", "Z", FieldAccessFlags::empty()),
34            ],
35            access_flags: ClassAccessFlags::empty(),
36        }
37    }
38
39    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, queue: ClassInstanceRef<TimerTaskQueue>) -> Result<()> {
40        tracing::debug!("java.util.Timer$TimerThread::<init>({this:?})");
41
42        let _: () = jvm.invoke_special(&this, "java/lang/Thread", "<init>", "()V", ()).await?;
43        jvm.put_field(&mut this, "java/util/Timer$TimerThread", "queue", "Ljava/util/Timer$TaskQueue;", queue)
44            .await?;
45        jvm.put_field(&mut this, "java/util/Timer$TimerThread", "newTasksMayBeScheduled", "Z", true)
46            .await?;
47        Ok(())
48    }
49
50    async fn run(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
51        tracing::debug!("java.util.Timer$TimerThread::run({this:?})");
52
53        let result = Self::main_loop(jvm, context, &this).await;
54        let mut thread = this;
55        let mut queue: ClassInstanceRef<TimerTaskQueue> = jvm
56            .get_field(&thread, "java/util/Timer$TimerThread", "queue", "Ljava/util/Timer$TaskQueue;")
57            .await?;
58        jvm.monitor_enter(&queue).await?;
59        let cleanup_result = async {
60            jvm.put_field(&mut thread, "java/util/Timer$TimerThread", "newTasksMayBeScheduled", "Z", false)
61                .await?;
62            TimerTaskQueue::clear(jvm, &mut queue).await?;
63            jvm.object_notify(&queue, usize::MAX).await
64        }
65        .await;
66        let exit_result = jvm.monitor_exit(&queue).await;
67
68        match result {
69            Ok(()) => {
70                cleanup_result?;
71                exit_result
72            }
73            Err(error) => {
74                if let Err(cleanup_error) = cleanup_result {
75                    exit_result?;
76                    return Err(cleanup_error);
77                }
78                exit_result?;
79                Err(error)
80            }
81        }
82    }
83
84    async fn main_loop(jvm: &Jvm, context: &mut RuntimeContext, this: &ClassInstanceRef<Self>) -> Result<()> {
85        let mut queue: ClassInstanceRef<TimerTaskQueue> = jvm
86            .get_field(this, "java/util/Timer$TimerThread", "queue", "Ljava/util/Timer$TaskQueue;")
87            .await?;
88
89        loop {
90            jvm.monitor_enter(&queue).await?;
91            let action_result = async {
92                loop {
93                    let size: i32 = jvm.get_field(&queue, "java/util/Timer$TaskQueue", "size", "I").await?;
94                    if size == 0 {
95                        if !jvm
96                            .get_field::<bool>(this, "java/util/Timer$TimerThread", "newTasksMayBeScheduled", "Z")
97                            .await?
98                        {
99                            return Ok(WorkerAction::Stop);
100                        }
101                        let wait_result: Result<()> = jvm.invoke_virtual(&queue, "java/lang/Object", "wait", "()V", ()).await;
102                        if let Err(error) = wait_result
103                            && !matches!(
104                                &error,
105                                JavaError::JavaException(exception)
106                                    if exception.class_definition().name() == "java/lang/InterruptedException"
107                            )
108                        {
109                            return Err(error);
110                        }
111                        continue;
112                    }
113
114                    let heap: ClassInstanceRef<Array<TimerTask>> = jvm
115                        .get_field(&queue, "java/util/Timer$TaskQueue", "queue", "[Ljava/util/TimerTask;")
116                        .await?;
117                    let mut task: ClassInstanceRef<TimerTask> = jvm.load_array(&heap, 1, 1).await?.remove(0);
118                    let lock: ClassInstanceRef<crate::classes::java::lang::Object> =
119                        jvm.get_field(&task, "java/util/TimerTask", "lock", "Ljava/lang/Object;").await?;
120                    jvm.monitor_enter(&lock).await?;
121                    let task_result = async {
122                        let state: i32 = jvm.get_field(&task, "java/util/TimerTask", "state", "I").await?;
123                        if state == TimerTask::CANCELLED {
124                            TimerTaskQueue::remove_min(jvm, &mut queue).await?;
125                            return Ok(WorkerAction::Continue);
126                        }
127
128                        let now = context.now() as i64;
129                        let execution_time: i64 = jvm.get_field(&task, "java/util/TimerTask", "nextExecutionTime", "J").await?;
130                        if execution_time > now {
131                            return Ok(WorkerAction::Continue);
132                        }
133
134                        let period: i64 = jvm.get_field(&task, "java/util/TimerTask", "period", "J").await?;
135                        jvm.put_field(&mut task, "java/util/TimerTask", "lastScheduledExecutionTime", "J", execution_time)
136                            .await?;
137                        if period == 0 {
138                            TimerTaskQueue::remove_min(jvm, &mut queue).await?;
139                            jvm.put_field(&mut task, "java/util/TimerTask", "state", "I", TimerTask::EXECUTED).await?;
140                        } else {
141                            let next_execution_time = if period < 0 {
142                                now.checked_sub(period)
143                            } else {
144                                execution_time.checked_add(period)
145                            };
146                            if let Some(next_execution_time) = next_execution_time {
147                                TimerTaskQueue::reschedule_min(jvm, &mut queue, next_execution_time).await?;
148                            } else {
149                                TimerTaskQueue::remove_min(jvm, &mut queue).await?;
150                                jvm.put_field(&mut task, "java/util/TimerTask", "state", "I", TimerTask::EXECUTED).await?;
151                            }
152                        }
153                        Ok(WorkerAction::Run(task.clone()))
154                    }
155                    .await;
156                    let task_exit_result = jvm.monitor_exit(&lock).await;
157                    let action = match task_result {
158                        Ok(action) => {
159                            task_exit_result?;
160                            action
161                        }
162                        Err(error) => {
163                            task_exit_result?;
164                            return Err(error);
165                        }
166                    };
167
168                    if matches!(action, WorkerAction::Run(_)) {
169                        return Ok(action);
170                    }
171                    let next_size: i32 = jvm.get_field(&queue, "java/util/Timer$TaskQueue", "size", "I").await?;
172                    if next_size == 0 {
173                        continue;
174                    }
175                    let next_heap: ClassInstanceRef<Array<TimerTask>> = jvm
176                        .get_field(&queue, "java/util/Timer$TaskQueue", "queue", "[Ljava/util/TimerTask;")
177                        .await?;
178                    let next_task: ClassInstanceRef<TimerTask> = jvm.load_array(&next_heap, 1, 1).await?.remove(0);
179                    let next_execution_time: i64 = jvm.get_field(&next_task, "java/util/TimerTask", "nextExecutionTime", "J").await?;
180                    let now = context.now() as i64;
181                    if next_execution_time <= now {
182                        continue;
183                    }
184                    let wait_result: Result<()> = jvm
185                        .invoke_virtual(&queue, "java/lang/Object", "wait", "(J)V", (next_execution_time - now,))
186                        .await;
187                    if let Err(error) = wait_result
188                        && !matches!(
189                            &error,
190                            JavaError::JavaException(exception)
191                                if exception.class_definition().name() == "java/lang/InterruptedException"
192                        )
193                    {
194                        return Err(error);
195                    }
196                }
197            }
198            .await;
199            let queue_exit_result = jvm.monitor_exit(&queue).await;
200            let action = match action_result {
201                Ok(action) => {
202                    queue_exit_result?;
203                    action
204                }
205                Err(error) => {
206                    queue_exit_result?;
207                    return Err(error);
208                }
209            };
210
211            match action {
212                WorkerAction::Continue => {}
213                WorkerAction::Run(task) => {
214                    let _: () = jvm.invoke_virtual(&task, "java/util/TimerTask", "run", "()V", ()).await?;
215                }
216                WorkerAction::Stop => return Ok(()),
217            }
218        }
219    }
220}