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
13pub 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 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(¤t_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}