多线程测试完成，闭包和死锁可以成功使用

tests/thread_test.rs

@@ -1,23 +1,57 @@
 use std::thread;
-use std::time::Duration;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+use std::sync::{Arc, Mutex};
 use std::io::{self, Write};
-use std::sync::Arc;
 
-struct Runner;
+struct Runner1 {
+    number: Arc<Mutex<f64>>,
+}
+
+impl Runner1 {
+    fn new(number: f64) -> Runner1 {
+        Runner1 {
+            number: Arc::new(Mutex::new(number)),
+        }
+    }
 
-impl Runner {
-    fn run1(&self) -> io::Result<()> {
+    fn run(&self) -> io::Result<()> {
         let mut stdout = io::stdout();
         loop {
-            writeln!(stdout, "111")?;
+            let number = *self.number.lock().unwrap();
+            writeln!(stdout, "Current number: {}", number)?;
             thread::sleep(Duration::from_millis(100));
         }
     }
 
-    fn run2(&self) -> io::Result<()> {
+    fn update_number(&self) -> Box<dyn Fn(f64) + Send + Sync> {
+        let number = Arc::clone(&self.number);
+        Box::new(move |new_number: f64| {
+            let mut num = number.lock().unwrap();
+            *num = new_number;
+        })
+    }
+}
+
+struct Runner2 {
+    update_hook: Box<dyn Fn(f64) + Send + Sync>,
+}
+
+impl Runner2 {
+    fn new(update_hook: Box<dyn Fn(f64) + Send + Sync>) -> Runner2 {
+        Runner2 {
+            update_hook,
+        }
+    }
+
+    fn run(&self) -> io::Result<()> {
         let mut stdout = io::stdout();
         loop {
-            writeln!(stdout, "222")?;
+            let now = SystemTime::now();
+            let since_the_epoch = now.duration_since(UNIX_EPOCH).unwrap();
+            let secs = since_the_epoch.as_secs();
+            let new_number = secs as f64;
+            (self.update_hook)(new_number);
+            writeln!(stdout, "Number after run2: {}", new_number)?;
             thread::sleep(Duration::from_millis(100));
         }
     }
@@ -25,17 +59,15 @@ impl Runner {
 
 #[tokio::test]
 async fn test_thread() {
-    let runner = Arc::new(Runner);
-
-    let runner1 = Arc::clone(&runner);
-    let runner2 = Arc::clone(&runner);
+    let runner1 = Arc::new(Runner1::new(1.0));
+    let runner2 = Runner2::new(runner1.update_number());
 
     let handle1 = thread::spawn(move || {
-        let _ = runner1.run1();
+        let _ = runner1.run();
     });
 
     let handle2 = thread::spawn(move || {
-        let _ = runner2.run2();
+        let _ = runner2.run();
     });
 
     let _ = handle1.join();