feat: thread is exited

Author: AsakuraMizu

src/process.rs

@@ -158,10 +158,7 @@ impl Process {
 impl Process {
     /// Creates a new [`Thread`] in this [`Process`].
     pub fn new_thread(self: &Arc<Self>, tid: Pid) -> Arc<Thread> {
-        let thread = Arc::new(Thread {
-            tid,
-            process: self.clone(),
-        });
+        let thread = Arc::new(Thread::new(tid, self.clone()));
         self.tg.lock().threads.insert(tid, &thread);
         thread
     }

src/thread.rs

@@ -1,15 +1,27 @@
 use alloc::sync::Arc;
-use core::fmt;
+use core::{
+    fmt,
+    sync::atomic::{AtomicBool, Ordering},
+};
 
 use crate::{Pid, Process};
 
 /// A thread.
 pub struct Thread {
-    pub(crate) tid: Pid,
-    pub(crate) process: Arc<Process>,
+    tid: Pid,
+    process: Arc<Process>,
+    exited: AtomicBool,
 }
 
 impl Thread {
+    pub(crate) fn new(tid: Pid, process: Arc<Process>) -> Self {
+        Self {
+            tid,
+            process,
+            exited: AtomicBool::new(false),
+        }
+    }
+
     /// The [`Thread`] ID.
     pub fn tid(&self) -> Pid {
         self.tid
@@ -24,13 +36,21 @@ impl Thread {
     ///
     /// Returns `true` if the thread was the last one in the thread group.
     pub fn exit(&self, exit_code: i32) -> bool {
+        if self.exited.swap(true, Ordering::SeqCst) {
+            return false; // Already exited
+        }
         let mut tg = self.process.tg.lock();
         if !tg.group_exited {
             tg.exit_code = exit_code;
         }
         tg.threads.remove(&self.tid);
         tg.threads.is_empty()
     }
+
+    /// Returns `true` if the thread has exited.
+    pub fn is_exited(&self) -> bool {
+        self.exited.load(Ordering::SeqCst)
+    }
 }
 
 impl fmt::Debug for Thread {