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, "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(¤t_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}