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, "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}