Skip to main content

rustjava_runtime/classes/java/lang/
thread.rs

1use alloc::{boxed::Box, format, vec};
2use core::time::Duration;
3
4use jvm::{ClassInstanceRef, GlobalRef, Jvm, Result, runtime::JavaLangString};
5use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
6use jvm_types::{FieldAccessFlags, MethodAccessFlags};
7
8use crate::{
9    RuntimeClassProto, RuntimeContext, SpawnCallback,
10    classes::java::lang::{Runnable, String},
11};
12
13// class java.lang.Thread
14pub struct Thread;
15
16impl Thread {
17    pub fn as_proto() -> RuntimeClassProto {
18        RuntimeClassProto {
19            name: "java/lang/Thread",
20            parent_class: Some("java/lang/Object"),
21            interfaces: vec!["java/lang/Runnable"],
22            methods: vec![
23                JavaMethodProto::new("<clinit>", "()V", Self::clinit, MethodAccessFlags::STATIC),
24                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
25                JavaMethodProto::new("<init>", "(Ljava/lang/Runnable;)V", Self::init_with_runnable, MethodAccessFlags::PUBLIC),
26                JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_with_name, MethodAccessFlags::PUBLIC),
27                JavaMethodProto::new(
28                    "<init>",
29                    "(Ljava/lang/Runnable;Ljava/lang/String;)V",
30                    Self::init_with_runnable_and_name,
31                    MethodAccessFlags::PUBLIC,
32                ),
33                JavaMethodProto::new("start", "()V", Self::start, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
34                JavaMethodProto::new(
35                    "join",
36                    "()V",
37                    Self::join,
38                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL | MethodAccessFlags::SYNCHRONIZED,
39                ),
40                JavaMethodProto::new(
41                    "join",
42                    "(J)V",
43                    Self::join_long,
44                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL | MethodAccessFlags::SYNCHRONIZED,
45                ),
46                JavaMethodProto::new("run", "()V", Self::run, MethodAccessFlags::PUBLIC),
47                JavaMethodProto::new("isAlive", "()Z", Self::is_alive, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
48                JavaMethodProto::new(
49                    "getName",
50                    "()Ljava/lang/String;",
51                    Self::get_name,
52                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
53                ),
54                JavaMethodProto::new(
55                    "setName",
56                    "(Ljava/lang/String;)V",
57                    Self::set_name,
58                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
59                ),
60                JavaMethodProto::new(
61                    "getPriority",
62                    "()I",
63                    Self::get_priority,
64                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
65                ),
66                JavaMethodProto::new("interrupt", "()V", Self::interrupt, MethodAccessFlags::PUBLIC),
67                JavaMethodProto::new("isInterrupted", "()Z", Self::is_interrupted, MethodAccessFlags::PUBLIC),
68                JavaMethodProto::new(
69                    "interrupted",
70                    "()Z",
71                    Self::interrupted,
72                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
73                ),
74                JavaMethodProto::new(
75                    "activeCount",
76                    "()I",
77                    Self::active_count,
78                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
79                ),
80                JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, MethodAccessFlags::PUBLIC),
81                JavaMethodProto::new(
82                    "sleep",
83                    "(J)V",
84                    Self::sleep,
85                    MethodAccessFlags::PUBLIC | MethodAccessFlags::NATIVE | MethodAccessFlags::STATIC,
86                ),
87                JavaMethodProto::new(
88                    "yield",
89                    "()V",
90                    Self::r#yield,
91                    MethodAccessFlags::PUBLIC | MethodAccessFlags::NATIVE | MethodAccessFlags::STATIC,
92                ),
93                JavaMethodProto::new(
94                    "setPriority",
95                    "(I)V",
96                    Self::set_priority,
97                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
98                ),
99                JavaMethodProto::new(
100                    "setDaemon",
101                    "(Z)V",
102                    Self::set_daemon,
103                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
104                ),
105                JavaMethodProto::new("isDaemon", "()Z", Self::is_daemon, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
106                JavaMethodProto::new(
107                    "currentThread",
108                    "()Ljava/lang/Thread;",
109                    Self::current_thread,
110                    MethodAccessFlags::PUBLIC | MethodAccessFlags::NATIVE | MethodAccessFlags::STATIC,
111                ),
112                // rustjava internal
113                JavaMethodProto::new("<init>", "(Z)V", Self::init_internal, MethodAccessFlags::PRIVATE),
114            ],
115            fields: vec![
116                JavaFieldProto::new(
117                    "MIN_PRIORITY",
118                    "I",
119                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
120                ),
121                JavaFieldProto::new(
122                    "NORM_PRIORITY",
123                    "I",
124                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
125                ),
126                JavaFieldProto::new(
127                    "MAX_PRIORITY",
128                    "I",
129                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
130                ),
131                JavaFieldProto::new("threadInitNumber", "I", FieldAccessFlags::PRIVATE | FieldAccessFlags::STATIC),
132                JavaFieldProto::new("id", "J", FieldAccessFlags::PRIVATE),
133                JavaFieldProto::new("target", "Ljava/lang/Runnable;", FieldAccessFlags::PRIVATE),
134                JavaFieldProto::new("name", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
135                JavaFieldProto::new("priority", "I", FieldAccessFlags::PRIVATE),
136                JavaFieldProto::new("interrupted", "Z", FieldAccessFlags::PRIVATE),
137                JavaFieldProto::new("started", "Z", FieldAccessFlags::PRIVATE),
138                JavaFieldProto::new("alive", "Z", FieldAccessFlags::PRIVATE),
139                JavaFieldProto::new("daemon", "Z", FieldAccessFlags::PRIVATE),
140            ],
141            access_flags: jvm_types::ClassAccessFlags::PUBLIC,
142        }
143    }
144
145    async fn clinit(jvm: &Jvm, _: &mut RuntimeContext) -> Result<()> {
146        jvm.put_static_field("java/lang/Thread", "MIN_PRIORITY", "I", 1i32).await?;
147        jvm.put_static_field("java/lang/Thread", "NORM_PRIORITY", "I", 5i32).await?;
148        jvm.put_static_field("java/lang/Thread", "MAX_PRIORITY", "I", 10i32).await?;
149        jvm.put_static_field("java/lang/Thread", "threadInitNumber", "I", 0i32).await
150    }
151
152    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
153        tracing::debug!("java.lang.Thread::<init>({this:?})");
154
155        let number: i32 = jvm.get_static_field("java/lang/Thread", "threadInitNumber", "I").await?;
156        jvm.put_static_field("java/lang/Thread", "threadInitNumber", "I", number + 1).await?;
157        let name = JavaLangString::from_rust_string(jvm, &format!("Thread-{number}")).await?;
158        let target = ClassInstanceRef::<Runnable>::new(None);
159        let _: () = jvm
160            .invoke_special(
161                &this,
162                "java/lang/Thread",
163                "<init>",
164                "(Ljava/lang/Runnable;Ljava/lang/String;)V",
165                (target, name),
166            )
167            .await?;
168
169        Ok(())
170    }
171
172    async fn init_with_runnable(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, target: ClassInstanceRef<Runnable>) -> Result<()> {
173        tracing::debug!("java.lang.Thread::<init>({this:?}, {target:?})");
174
175        let number: i32 = jvm.get_static_field("java/lang/Thread", "threadInitNumber", "I").await?;
176        jvm.put_static_field("java/lang/Thread", "threadInitNumber", "I", number + 1).await?;
177        let name = JavaLangString::from_rust_string(jvm, &format!("Thread-{number}")).await?;
178        let _: () = jvm
179            .invoke_special(
180                &this,
181                "java/lang/Thread",
182                "<init>",
183                "(Ljava/lang/Runnable;Ljava/lang/String;)V",
184                (target, name),
185            )
186            .await?;
187
188        Ok(())
189    }
190
191    async fn init_with_name(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, name: ClassInstanceRef<String>) -> Result<()> {
192        tracing::debug!("java.lang.Thread::<init>({this:?}, {name:?})");
193
194        let target = ClassInstanceRef::<Runnable>::new(None);
195        let _: () = jvm
196            .invoke_special(
197                &this,
198                "java/lang/Thread",
199                "<init>",
200                "(Ljava/lang/Runnable;Ljava/lang/String;)V",
201                (target, name),
202            )
203            .await?;
204
205        Ok(())
206    }
207
208    async fn init_with_runnable_and_name(
209        jvm: &Jvm,
210        _: &mut RuntimeContext,
211        mut this: ClassInstanceRef<Self>,
212        target: ClassInstanceRef<Runnable>,
213        name: ClassInstanceRef<String>,
214    ) -> Result<()> {
215        tracing::debug!("java.lang.Thread::<init>({this:?}, {target:?}, {name:?})");
216
217        if name.is_null() {
218            return Err(jvm.exception("java/lang/NullPointerException", "name").await);
219        }
220
221        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
222        jvm.put_field(&mut this, "java/lang/Thread", "target", "Ljava/lang/Runnable;", target)
223            .await?;
224        jvm.put_field(&mut this, "java/lang/Thread", "name", "Ljava/lang/String;", name).await?;
225        jvm.put_field(&mut this, "java/lang/Thread", "priority", "I", 5i32).await?;
226        jvm.put_field(&mut this, "java/lang/Thread", "interrupted", "Z", false).await?;
227        jvm.put_field(&mut this, "java/lang/Thread", "started", "Z", false).await?;
228        jvm.put_field(&mut this, "java/lang/Thread", "alive", "Z", false).await?;
229        let current_thread = jvm.current_java_thread();
230        let daemon: bool = jvm.get_field(&current_thread, "java/lang/Thread", "daemon", "Z").await?;
231        jvm.put_field(&mut this, "java/lang/Thread", "daemon", "Z", daemon).await?;
232
233        Ok(())
234    }
235
236    async fn init_internal(jvm: &Jvm, context: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, internal: bool) -> Result<()> {
237        tracing::debug!("java.lang.Thread::<init>({this:?}, {internal:?})");
238
239        let id = context.current_task_id();
240        jvm.put_field(&mut this, "java/lang/Thread", "id", "J", id as i64).await?;
241        jvm.put_field(&mut this, "java/lang/Thread", "priority", "I", 5i32).await?;
242        jvm.put_field(&mut this, "java/lang/Thread", "interrupted", "Z", false).await?;
243        jvm.put_field(&mut this, "java/lang/Thread", "started", "Z", true).await?;
244        jvm.put_field(&mut this, "java/lang/Thread", "alive", "Z", internal).await?;
245        jvm.put_field(&mut this, "java/lang/Thread", "daemon", "Z", false).await?;
246
247        Ok(())
248    }
249
250    async fn start(jvm: &Jvm, context: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
251        tracing::debug!("java.lang.Thread::start({this:?})");
252
253        let started: bool = jvm.get_field(&this, "java/lang/Thread", "started", "Z").await?;
254        if started {
255            return Err(jvm.exception("java/lang/IllegalThreadStateException", "thread already started").await);
256        }
257
258        struct ThreadStartProxy {
259            jvm: Jvm,
260            thread_id: i32,
261            this: GlobalRef<Thread>,
262        }
263
264        #[async_trait::async_trait]
265        impl SpawnCallback for ThreadStartProxy {
266            #[tracing::instrument(name = "java thread", fields(id = self.thread_id), skip_all)]
267            async fn call(&self) -> Result<()> {
268                tracing::trace!("Thread start");
269
270                self.jvm.attach_thread(self.this.instance.clone()).await?;
271
272                let result: Result<()> = self.jvm.invoke_virtual(&self.this, "java/lang/Thread", "run", "()V", []).await;
273
274                if let Err(jvm::JavaError::JavaException(exception)) = &result {
275                    let trace = async {
276                        let string_writer = self.jvm.new_class("java/io/StringWriter", "()V", ()).await?;
277                        let print_writer = self
278                            .jvm
279                            .new_class("java/io/PrintWriter", "(Ljava/io/Writer;)V", (string_writer.clone(),))
280                            .await?;
281                        let _: () = self
282                            .jvm
283                            .invoke_virtual(
284                                exception,
285                                &exception.class_definition().name(),
286                                "printStackTrace",
287                                "(Ljava/io/PrintWriter;)V",
288                                (print_writer,),
289                            )
290                            .await?;
291                        let trace = self
292                            .jvm
293                            .invoke_virtual(&string_writer, "java/io/StringWriter", "toString", "()Ljava/lang/String;", [])
294                            .await?;
295                        JavaLangString::to_rust_string(&self.jvm, &trace).await
296                    }
297                    .await;
298
299                    match trace {
300                        Ok(trace) => tracing::error!("Uncaught exception in thread {}:\n{}", self.thread_id, trace),
301                        Err(error) => tracing::error!(?error, "failed to format uncaught exception in thread {}", self.thread_id),
302                    }
303                }
304
305                let mut this = (*self.this).clone();
306                let cleanup = if let Err(error) = self.jvm.monitor_enter(&self.this).await {
307                    Err(error)
308                } else {
309                    let alive_result = self.jvm.put_field(&mut this, "java/lang/Thread", "alive", "Z", false).await;
310                    let notify_result = if alive_result.is_ok() {
311                        self.jvm.object_notify(&self.this, usize::MAX).await
312                    } else {
313                        Ok(())
314                    };
315                    let exit_result = self.jvm.monitor_exit(&self.this).await;
316                    alive_result.and(notify_result).and(exit_result)
317                };
318                let detach_result = self.jvm.detach_thread();
319
320                cleanup?;
321                detach_result?;
322
323                Ok(())
324            }
325        }
326
327        jvm.put_field(&mut this, "java/lang/Thread", "started", "Z", true).await?;
328        jvm.put_field(&mut this, "java/lang/Thread", "alive", "Z", true).await?;
329
330        let id: i32 = jvm.invoke_virtual(&this, "java/lang/Object", "hashCode", "()I", ()).await?;
331
332        let this = match jvm.new_global_ref(&this) {
333            Some(this) => this,
334            None => return Err(jvm.exception("java/lang/NullPointerException", "thread is null").await),
335        };
336        context.spawn(
337            jvm,
338            Box::new(ThreadStartProxy {
339                jvm: jvm.clone(),
340                thread_id: id,
341                this,
342            }),
343        );
344
345        Ok(())
346    }
347
348    async fn run(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
349        tracing::debug!("java.lang.Thread::run({this:?})");
350
351        let target: ClassInstanceRef<Runnable> = jvm.get_field(&this, "java/lang/Thread", "target", "Ljava/lang/Runnable;").await?;
352        if !target.is_null() {
353            let _: () = jvm.invoke_virtual(&target, &target.class_definition().name(), "run", "()V", ()).await?;
354        }
355
356        Ok(())
357    }
358
359    async fn join(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
360        tracing::debug!("java.lang.Thread::join({this:?})");
361
362        let _: () = jvm.invoke_virtual(&this, "java/lang/Thread", "join", "(J)V", (0i64,)).await?;
363
364        Ok(())
365    }
366
367    async fn join_long(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>, millis: i64) -> Result<()> {
368        tracing::debug!("java.lang.Thread::join({this:?}, {millis:?})");
369
370        if millis < 0 {
371            return Err(jvm.exception("java/lang/IllegalArgumentException", "timeout value is negative").await);
372        }
373
374        let start = context.now();
375        loop {
376            let alive: bool = jvm.get_field(&this, "java/lang/Thread", "alive", "Z").await?;
377            if !alive {
378                return Ok(());
379            }
380
381            if millis == 0 {
382                let _: () = jvm.invoke_virtual(&this, "java/lang/Object", "wait", "(J)V", (0i64,)).await?;
383            } else {
384                let elapsed = context.now().saturating_sub(start);
385                if elapsed >= millis as u64 {
386                    return Ok(());
387                }
388                let _: () = jvm
389                    .invoke_virtual(&this, "java/lang/Object", "wait", "(J)V", (millis - elapsed as i64,))
390                    .await?;
391            }
392        }
393    }
394
395    async fn is_alive(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
396        tracing::debug!("java.lang.Thread::isAlive({this:?})");
397        let alive: bool = jvm.get_field(&this, "java/lang/Thread", "alive", "Z").await?;
398        Ok(alive)
399    }
400
401    async fn get_name(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
402        tracing::debug!("java.lang.Thread::getName({this:?})");
403
404        let name: ClassInstanceRef<String> = jvm.get_field(&this, "java/lang/Thread", "name", "Ljava/lang/String;").await?;
405        if name.is_null() {
406            return Ok(JavaLangString::from_rust_string(jvm, "main").await?.into());
407        }
408
409        Ok(name)
410    }
411
412    async fn set_name(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, name: ClassInstanceRef<String>) -> Result<()> {
413        tracing::debug!("java.lang.Thread::setName({this:?}, {name:?})");
414
415        if name.is_null() {
416            return Err(jvm.exception("java/lang/NullPointerException", "name").await);
417        }
418
419        jvm.put_field(&mut this, "java/lang/Thread", "name", "Ljava/lang/String;", name).await
420    }
421
422    async fn get_priority(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
423        tracing::debug!("java.lang.Thread::getPriority({this:?})");
424        jvm.get_field(&this, "java/lang/Thread", "priority", "I").await
425    }
426
427    async fn interrupt(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
428        tracing::debug!("java.lang.Thread::interrupt({this:?})");
429        jvm.interrupt_java_thread(&mut this).await
430    }
431
432    async fn is_interrupted(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
433        tracing::debug!("java.lang.Thread::isInterrupted({this:?})");
434        jvm.is_java_thread_interrupted(&this).await
435    }
436
437    async fn interrupted(jvm: &Jvm, _: &mut RuntimeContext) -> Result<bool> {
438        tracing::debug!("java.lang.Thread::interrupted()");
439        jvm.current_java_thread_interrupted().await
440    }
441
442    async fn active_count(jvm: &Jvm, _: &mut RuntimeContext) -> Result<i32> {
443        Ok(jvm.active_thread_count() as i32)
444    }
445
446    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
447        tracing::debug!("java.lang.Thread::toString({this:?})");
448
449        let name: ClassInstanceRef<String> = jvm
450            .invoke_virtual(&this, "java/lang/Thread", "getName", "()Ljava/lang/String;", ())
451            .await?;
452        let name = JavaLangString::to_rust_string(jvm, &name).await?;
453        let priority: i32 = jvm.get_field(&this, "java/lang/Thread", "priority", "I").await?;
454        Ok(JavaLangString::from_rust_string(jvm, &format!("Thread[{name},{priority}]")).await?.into())
455    }
456
457    async fn sleep(jvm: &Jvm, context: &mut RuntimeContext, duration: i64) -> Result<()> {
458        tracing::debug!("java.lang.Thread::sleep({duration:?})");
459
460        if duration < 0 {
461            return Err(jvm.exception("java/lang/IllegalArgumentException", "timeout value is negative").await);
462        }
463
464        jvm.sleep_interruptibly(context.sleep(Duration::from_millis(duration as _))).await
465    }
466
467    async fn r#yield(_: &Jvm, context: &mut RuntimeContext) -> Result<()> {
468        tracing::debug!("java.lang.Thread::yield()");
469        context.r#yield().await;
470
471        Ok(())
472    }
473
474    async fn set_priority(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Thread>, new_priority: i32) -> Result<()> {
475        tracing::debug!("java.lang.Thread::setPriority({this:?}, {new_priority:?})");
476
477        if !(1..=10).contains(&new_priority) {
478            return Err(jvm.exception("java/lang/IllegalArgumentException", "priority out of range").await);
479        }
480
481        jvm.put_field(&mut this, "java/lang/Thread", "priority", "I", new_priority).await?;
482
483        Ok(())
484    }
485
486    async fn set_daemon(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Thread>, daemon: bool) -> Result<()> {
487        tracing::debug!("java.lang.Thread::setDaemon({this:?}, {daemon:?})");
488
489        let alive: bool = jvm.get_field(&this, "java/lang/Thread", "alive", "Z").await?;
490        if alive {
491            return Err(jvm.exception("java/lang/IllegalThreadStateException", "thread is active").await);
492        }
493
494        jvm.put_field(&mut this, "java/lang/Thread", "daemon", "Z", daemon).await
495    }
496
497    async fn is_daemon(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Thread>) -> Result<bool> {
498        tracing::debug!("java.lang.Thread::isDaemon({this:?})");
499        jvm.get_field(&this, "java/lang/Thread", "daemon", "Z").await
500    }
501
502    async fn current_thread(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
503        tracing::debug!("java.lang.Thread::currentThread()");
504
505        Ok(jvm.current_java_thread().into())
506    }
507}