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, "target", "Ljava/lang/Runnable;", target).await?;
223        jvm.put_field(&mut this, "name", "Ljava/lang/String;", name).await?;
224        jvm.put_field(&mut this, "priority", "I", 5i32).await?;
225        jvm.put_field(&mut this, "interrupted", "Z", false).await?;
226        jvm.put_field(&mut this, "started", "Z", false).await?;
227        jvm.put_field(&mut this, "alive", "Z", false).await?;
228        let current_thread = jvm.current_java_thread();
229        let daemon: bool = jvm.get_field(&current_thread, "daemon", "Z").await?;
230        jvm.put_field(&mut this, "daemon", "Z", daemon).await?;
231
232        Ok(())
233    }
234
235    async fn init_internal(jvm: &Jvm, context: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, internal: bool) -> Result<()> {
236        tracing::debug!("java.lang.Thread::<init>({this:?}, {internal:?})");
237
238        let id = context.current_task_id();
239        jvm.put_field(&mut this, "id", "J", id as i64).await?;
240        jvm.put_field(&mut this, "priority", "I", 5i32).await?;
241        jvm.put_field(&mut this, "interrupted", "Z", false).await?;
242        jvm.put_field(&mut this, "started", "Z", true).await?;
243        jvm.put_field(&mut this, "alive", "Z", internal).await?;
244        jvm.put_field(&mut this, "daemon", "Z", false).await?;
245
246        Ok(())
247    }
248
249    async fn start(jvm: &Jvm, context: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
250        tracing::debug!("java.lang.Thread::start({this:?})");
251
252        let started: bool = jvm.get_field(&this, "started", "Z").await?;
253        if started {
254            return Err(jvm.exception("java/lang/IllegalThreadStateException", "thread already started").await);
255        }
256
257        struct ThreadStartProxy {
258            jvm: Jvm,
259            thread_id: i32,
260            this: GlobalRef<Thread>,
261        }
262
263        #[async_trait::async_trait]
264        impl SpawnCallback for ThreadStartProxy {
265            #[tracing::instrument(name = "java thread", fields(id = self.thread_id), skip_all)]
266            async fn call(&self) -> Result<()> {
267                tracing::trace!("Thread start");
268
269                self.jvm.attach_thread(self.this.instance.clone()).await?;
270
271                let result: Result<()> = self.jvm.invoke_virtual(&self.this, "java/lang/Thread", "run", "()V", []).await;
272
273                if let Err(jvm::JavaError::JavaException(exception)) = &result {
274                    let trace = async {
275                        let string_writer = self.jvm.new_class("java/io/StringWriter", "()V", ()).await?;
276                        let print_writer = self
277                            .jvm
278                            .new_class("java/io/PrintWriter", "(Ljava/io/Writer;)V", (string_writer.clone(),))
279                            .await?;
280                        let _: () = self
281                            .jvm
282                            .invoke_virtual(
283                                exception,
284                                &exception.class_definition().name(),
285                                "printStackTrace",
286                                "(Ljava/io/PrintWriter;)V",
287                                (print_writer,),
288                            )
289                            .await?;
290                        let trace = self
291                            .jvm
292                            .invoke_virtual(&string_writer, "java/io/StringWriter", "toString", "()Ljava/lang/String;", [])
293                            .await?;
294                        JavaLangString::to_rust_string(&self.jvm, &trace).await
295                    }
296                    .await;
297
298                    match trace {
299                        Ok(trace) => tracing::error!("Uncaught exception in thread {}:\n{}", self.thread_id, trace),
300                        Err(error) => tracing::error!(?error, "failed to format uncaught exception in thread {}", self.thread_id),
301                    }
302                }
303
304                let mut this = (*self.this).clone();
305                let cleanup = if let Err(error) = self.jvm.monitor_enter(&self.this).await {
306                    Err(error)
307                } else {
308                    let alive_result = self.jvm.put_field(&mut this, "alive", "Z", false).await;
309                    let notify_result = if alive_result.is_ok() {
310                        self.jvm.object_notify(&self.this, usize::MAX).await
311                    } else {
312                        Ok(())
313                    };
314                    let exit_result = self.jvm.monitor_exit(&self.this).await;
315                    alive_result.and(notify_result).and(exit_result)
316                };
317                let detach_result = self.jvm.detach_thread();
318
319                cleanup?;
320                detach_result?;
321
322                Ok(())
323            }
324        }
325
326        jvm.put_field(&mut this, "started", "Z", true).await?;
327        jvm.put_field(&mut this, "alive", "Z", true).await?;
328
329        let id: i32 = jvm.invoke_virtual(&this, "java/lang/Object", "hashCode", "()I", ()).await?;
330
331        let this = match jvm.new_global_ref(&this) {
332            Some(this) => this,
333            None => return Err(jvm.exception("java/lang/NullPointerException", "thread is null").await),
334        };
335        context.spawn(
336            jvm,
337            Box::new(ThreadStartProxy {
338                jvm: jvm.clone(),
339                thread_id: id,
340                this,
341            }),
342        );
343
344        Ok(())
345    }
346
347    async fn run(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
348        tracing::debug!("java.lang.Thread::run({this:?})");
349
350        let target: ClassInstanceRef<Runnable> = jvm.get_field(&this, "target", "Ljava/lang/Runnable;").await?;
351        if !target.is_null() {
352            let _: () = jvm.invoke_virtual(&target, &target.class_definition().name(), "run", "()V", ()).await?;
353        }
354
355        Ok(())
356    }
357
358    async fn join(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
359        tracing::debug!("java.lang.Thread::join({this:?})");
360
361        let _: () = jvm.invoke_virtual(&this, "java/lang/Thread", "join", "(J)V", (0i64,)).await?;
362
363        Ok(())
364    }
365
366    async fn join_long(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>, millis: i64) -> Result<()> {
367        tracing::debug!("java.lang.Thread::join({this:?}, {millis:?})");
368
369        if millis < 0 {
370            return Err(jvm.exception("java/lang/IllegalArgumentException", "timeout value is negative").await);
371        }
372
373        let start = context.now();
374        loop {
375            let alive: bool = jvm.get_field(&this, "alive", "Z").await?;
376            if !alive {
377                return Ok(());
378            }
379
380            if millis == 0 {
381                let _: () = jvm.invoke_virtual(&this, "java/lang/Object", "wait", "(J)V", (0i64,)).await?;
382            } else {
383                let elapsed = context.now().saturating_sub(start);
384                if elapsed >= millis as u64 {
385                    return Ok(());
386                }
387                let _: () = jvm
388                    .invoke_virtual(&this, "java/lang/Object", "wait", "(J)V", (millis - elapsed as i64,))
389                    .await?;
390            }
391        }
392    }
393
394    async fn is_alive(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
395        tracing::debug!("java.lang.Thread::isAlive({this:?})");
396        let alive: bool = jvm.get_field(&this, "alive", "Z").await?;
397        Ok(alive)
398    }
399
400    async fn get_name(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
401        tracing::debug!("java.lang.Thread::getName({this:?})");
402
403        let name: ClassInstanceRef<String> = jvm.get_field(&this, "name", "Ljava/lang/String;").await?;
404        if name.is_null() {
405            return Ok(JavaLangString::from_rust_string(jvm, "main").await?.into());
406        }
407
408        Ok(name)
409    }
410
411    async fn set_name(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, name: ClassInstanceRef<String>) -> Result<()> {
412        tracing::debug!("java.lang.Thread::setName({this:?}, {name:?})");
413
414        if name.is_null() {
415            return Err(jvm.exception("java/lang/NullPointerException", "name").await);
416        }
417
418        jvm.put_field(&mut this, "name", "Ljava/lang/String;", name).await
419    }
420
421    async fn get_priority(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
422        tracing::debug!("java.lang.Thread::getPriority({this:?})");
423        jvm.get_field(&this, "priority", "I").await
424    }
425
426    async fn interrupt(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
427        tracing::debug!("java.lang.Thread::interrupt({this:?})");
428        jvm.interrupt_java_thread(&mut this).await
429    }
430
431    async fn is_interrupted(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
432        tracing::debug!("java.lang.Thread::isInterrupted({this:?})");
433        jvm.is_java_thread_interrupted(&this).await
434    }
435
436    async fn interrupted(jvm: &Jvm, _: &mut RuntimeContext) -> Result<bool> {
437        tracing::debug!("java.lang.Thread::interrupted()");
438        jvm.current_java_thread_interrupted().await
439    }
440
441    async fn active_count(jvm: &Jvm, _: &mut RuntimeContext) -> Result<i32> {
442        Ok(jvm.active_thread_count() as i32)
443    }
444
445    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
446        tracing::debug!("java.lang.Thread::toString({this:?})");
447
448        let name: ClassInstanceRef<String> = jvm
449            .invoke_virtual(&this, "java/lang/Thread", "getName", "()Ljava/lang/String;", ())
450            .await?;
451        let name = JavaLangString::to_rust_string(jvm, &name).await?;
452        let priority: i32 = jvm.get_field(&this, "priority", "I").await?;
453        Ok(JavaLangString::from_rust_string(jvm, &format!("Thread[{name},{priority}]")).await?.into())
454    }
455
456    async fn sleep(jvm: &Jvm, context: &mut RuntimeContext, duration: i64) -> Result<()> {
457        tracing::debug!("java.lang.Thread::sleep({duration:?})");
458
459        if duration < 0 {
460            return Err(jvm.exception("java/lang/IllegalArgumentException", "timeout value is negative").await);
461        }
462
463        jvm.sleep_interruptibly(context.sleep(Duration::from_millis(duration as _))).await
464    }
465
466    async fn r#yield(_: &Jvm, context: &mut RuntimeContext) -> Result<()> {
467        tracing::debug!("java.lang.Thread::yield()");
468        context.r#yield().await;
469
470        Ok(())
471    }
472
473    async fn set_priority(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Thread>, new_priority: i32) -> Result<()> {
474        tracing::debug!("java.lang.Thread::setPriority({this:?}, {new_priority:?})");
475
476        if !(1..=10).contains(&new_priority) {
477            return Err(jvm.exception("java/lang/IllegalArgumentException", "priority out of range").await);
478        }
479
480        jvm.put_field(&mut this, "priority", "I", new_priority).await?;
481
482        Ok(())
483    }
484
485    async fn set_daemon(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Thread>, daemon: bool) -> Result<()> {
486        tracing::debug!("java.lang.Thread::setDaemon({this:?}, {daemon:?})");
487
488        let alive: bool = jvm.get_field(&this, "alive", "Z").await?;
489        if alive {
490            return Err(jvm.exception("java/lang/IllegalThreadStateException", "thread is active").await);
491        }
492
493        jvm.put_field(&mut this, "daemon", "Z", daemon).await
494    }
495
496    async fn is_daemon(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Thread>) -> Result<bool> {
497        tracing::debug!("java.lang.Thread::isDaemon({this:?})");
498        jvm.get_field(&this, "daemon", "Z").await
499    }
500
501    async fn current_thread(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
502        tracing::debug!("java.lang.Thread::currentThread()");
503
504        Ok(jvm.current_java_thread().into())
505    }
506}