rustjava_runtime/classes/java/util/
timer_thread.rs1use 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
18pub 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}