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, "queue", "Ljava/util/Timer$TaskQueue;", queue).await?;
44 jvm.put_field(&mut this, "newTasksMayBeScheduled", "Z", true).await?;
45 Ok(())
46 }
47
48 async fn run(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
49 tracing::debug!("java.util.Timer$TimerThread::run({this:?})");
50
51 let result = Self::main_loop(jvm, context, &this).await;
52 let mut thread = this;
53 let mut queue: ClassInstanceRef<TimerTaskQueue> = jvm.get_field(&thread, "queue", "Ljava/util/Timer$TaskQueue;").await?;
54 jvm.monitor_enter(&queue).await?;
55 let cleanup_result = async {
56 jvm.put_field(&mut thread, "newTasksMayBeScheduled", "Z", false).await?;
57 TimerTaskQueue::clear(jvm, &mut queue).await?;
58 jvm.object_notify(&queue, usize::MAX).await
59 }
60 .await;
61 let exit_result = jvm.monitor_exit(&queue).await;
62
63 match result {
64 Ok(()) => {
65 cleanup_result?;
66 exit_result
67 }
68 Err(error) => {
69 if let Err(cleanup_error) = cleanup_result {
70 exit_result?;
71 return Err(cleanup_error);
72 }
73 exit_result?;
74 Err(error)
75 }
76 }
77 }
78
79 async fn main_loop(jvm: &Jvm, context: &mut RuntimeContext, this: &ClassInstanceRef<Self>) -> Result<()> {
80 let mut queue: ClassInstanceRef<TimerTaskQueue> = jvm.get_field(this, "queue", "Ljava/util/Timer$TaskQueue;").await?;
81
82 loop {
83 jvm.monitor_enter(&queue).await?;
84 let action_result = async {
85 loop {
86 let size: i32 = jvm.get_field(&queue, "size", "I").await?;
87 if size == 0 {
88 if !jvm.get_field::<bool>(this, "newTasksMayBeScheduled", "Z").await? {
89 return Ok(WorkerAction::Stop);
90 }
91 let wait_result: Result<()> = jvm.invoke_virtual(&queue, "java/lang/Object", "wait", "()V", ()).await;
92 if let Err(error) = wait_result
93 && !matches!(
94 &error,
95 JavaError::JavaException(exception)
96 if exception.class_definition().name() == "java/lang/InterruptedException"
97 )
98 {
99 return Err(error);
100 }
101 continue;
102 }
103
104 let heap: ClassInstanceRef<Array<TimerTask>> = jvm.get_field(&queue, "queue", "[Ljava/util/TimerTask;").await?;
105 let mut task: ClassInstanceRef<TimerTask> = jvm.load_array(&heap, 1, 1).await?.remove(0);
106 let lock: ClassInstanceRef<crate::classes::java::lang::Object> = jvm.get_field(&task, "lock", "Ljava/lang/Object;").await?;
107 jvm.monitor_enter(&lock).await?;
108 let task_result = async {
109 let state: i32 = jvm.get_field(&task, "state", "I").await?;
110 if state == TimerTask::CANCELLED {
111 TimerTaskQueue::remove_min(jvm, &mut queue).await?;
112 return Ok(WorkerAction::Continue);
113 }
114
115 let now = context.now() as i64;
116 let execution_time: i64 = jvm.get_field(&task, "nextExecutionTime", "J").await?;
117 if execution_time > now {
118 return Ok(WorkerAction::Continue);
119 }
120
121 let period: i64 = jvm.get_field(&task, "period", "J").await?;
122 jvm.put_field(&mut task, "lastScheduledExecutionTime", "J", execution_time).await?;
123 if period == 0 {
124 TimerTaskQueue::remove_min(jvm, &mut queue).await?;
125 jvm.put_field(&mut task, "state", "I", TimerTask::EXECUTED).await?;
126 } else {
127 let next_execution_time = if period < 0 {
128 now.checked_sub(period)
129 } else {
130 execution_time.checked_add(period)
131 };
132 if let Some(next_execution_time) = next_execution_time {
133 TimerTaskQueue::reschedule_min(jvm, &mut queue, next_execution_time).await?;
134 } else {
135 TimerTaskQueue::remove_min(jvm, &mut queue).await?;
136 jvm.put_field(&mut task, "state", "I", TimerTask::EXECUTED).await?;
137 }
138 }
139 Ok(WorkerAction::Run(task.clone()))
140 }
141 .await;
142 let task_exit_result = jvm.monitor_exit(&lock).await;
143 let action = match task_result {
144 Ok(action) => {
145 task_exit_result?;
146 action
147 }
148 Err(error) => {
149 task_exit_result?;
150 return Err(error);
151 }
152 };
153
154 if matches!(action, WorkerAction::Run(_)) {
155 return Ok(action);
156 }
157 let next_size: i32 = jvm.get_field(&queue, "size", "I").await?;
158 if next_size == 0 {
159 continue;
160 }
161 let next_heap: ClassInstanceRef<Array<TimerTask>> = jvm.get_field(&queue, "queue", "[Ljava/util/TimerTask;").await?;
162 let next_task: ClassInstanceRef<TimerTask> = jvm.load_array(&next_heap, 1, 1).await?.remove(0);
163 let next_execution_time: i64 = jvm.get_field(&next_task, "nextExecutionTime", "J").await?;
164 let now = context.now() as i64;
165 if next_execution_time <= now {
166 continue;
167 }
168 let wait_result: Result<()> = jvm
169 .invoke_virtual(&queue, "java/lang/Object", "wait", "(J)V", (next_execution_time - now,))
170 .await;
171 if let Err(error) = wait_result
172 && !matches!(
173 &error,
174 JavaError::JavaException(exception)
175 if exception.class_definition().name() == "java/lang/InterruptedException"
176 )
177 {
178 return Err(error);
179 }
180 }
181 }
182 .await;
183 let queue_exit_result = jvm.monitor_exit(&queue).await;
184 let action = match action_result {
185 Ok(action) => {
186 queue_exit_result?;
187 action
188 }
189 Err(error) => {
190 queue_exit_result?;
191 return Err(error);
192 }
193 };
194
195 match action {
196 WorkerAction::Continue => {}
197 WorkerAction::Run(task) => {
198 let _: () = jvm.invoke_virtual(&task, "java/util/TimerTask", "run", "()V", ()).await?;
199 }
200 WorkerAction::Stop => return Ok(()),
201 }
202 }
203 }
204}