提交线程实验

Author: dorname

exercises/01_concurrency_sync/01_thread_spawn/src/lib.rs

@@ -35,6 +35,7 @@
 use std::cell::RefCell;
 #[allow(unused_imports)]
 use std::thread;
+use std::thread::sleep;
 #[allow(unused_imports)]
 use std::time::Duration;
 
@@ -154,20 +155,28 @@ use std::time::Duration;
 /// Hint: Use `thread::spawn` and `move` closure.
 #[allow(unused_variables)]
 pub fn double_in_thread(numbers: Vec<i32>) -> Vec<i32> {
-    // TODO: Create a new thread to multiply each element of numbers by 2
+    // Create a new thread to multiply each element of numbers by 2
     // Use thread::spawn and move closure
+    let handle = thread::spawn(move || {
+        numbers.iter().map( |i| i * 2).collect::<Vec<i32>>()
+    });
     // Use join().unwrap() to get result
-    todo!()
+    handle.join().unwrap()
 }
 
 /// Sum two vectors in parallel, returning a tuple of two sums.
 ///
 /// Hint: Create two threads for each vector.
 #[allow(unused_variables)]
 pub fn parallel_sum(a: Vec<i32>, b: Vec<i32>) -> (i32, i32) {
-    // TODO: Create two threads to sum a and b respectively
-    // Join both threads to get results
-    todo!()
+    // Create two threads to sum a and b respectively
+    let (sum_a,sum_b) = thread::scope(|s| {
+        let handle_a = s.spawn(|| a.iter().sum());
+        let handle_b = s.spawn(|| b.iter().sum());
+        (handle_a.join().unwrap(), handle_b.join().unwrap())
+    });
+    // Join both threads to get results()
+    (sum_a, sum_b)
 }
 
 // ============================================================================
@@ -182,10 +191,15 @@ pub fn parallel_sum(a: Vec<i32>, b: Vec<i32>) -> (i32, i32) {
 /// Hint: `thread::sleep` causes the current thread to block; it does not affect other threads.
 #[allow(unused_variables)]
 pub fn named_sleeper(value: i32, ms: u64) -> i32 {
-    // TODO: Create a thread builder with name "sleeper"
-    // TODO: Spawn a thread that sleeps for `ms` milliseconds and returns `value`
-    // TODO: Join the thread and return the value
-    todo!()
+    //  Create a thread builder with name "sleeper"
+    let builder = thread::Builder::new().name("sleeper".to_string());
+    //  Spawn a thread that sleeps for `ms` milliseconds and returns `value`
+    let handle = builder.spawn(move || {
+        sleep(Duration::from_millis(ms));
+        value
+    }).unwrap();
+    //  Join the thread and return the value
+    handle.join().unwrap()
 }
 
 thread_local! {
@@ -199,8 +213,17 @@ thread_local! {
 ///
 /// Hint: Use `THREAD_COUNT.with(|cell| { ... })` to access the thread‑local variable.
 pub fn increment_thread_local() -> usize {
-    // TODO: Use THREAD_COUNT.with to increment and return the new count
-    todo!()
+    // Use THREAD_COUNT.with to increment and return the new count
+    thread_local! {
+        pub static THREAD_COUNT: RefCell<usize> = const {
+            RefCell::new(0)
+        };
+    }
+    THREAD_COUNT.with(|thread_count|{
+        let mut count = thread_count.borrow_mut();
+        *count += 1;
+        *count }
+    )
 }
 
 /// Spawn two threads using a **scoped thread** to compute the sum of two slices without moving ownership.
@@ -213,10 +236,14 @@ pub fn increment_thread_local() -> usize {
 /// making the borrow safe.
 #[allow(unused_variables)]
 pub fn scoped_slice_sum(a: &[i32], b: &[i32]) -> (i32, i32) {
-    // TODO: Use thread::scope to spawn two threads
-    // TODO: Each thread sums its slice
-    // TODO: Wait for both threads and return the results
-    todo!()
+    // Use thread::scope to spawn two threads
+    // Each thread sums its slice
+    // Wait for both threads and return the results
+    thread::scope(|s| {
+        let handle_a = s.spawn(|| a.iter().sum());
+        let handle_b = s.spawn(|| b.iter().sum());
+        (handle_a.join().unwrap(), handle_b.join().unwrap())
+    })
 }
 
 /// Handle a possible panic in a spawned thread.
@@ -231,9 +258,19 @@ pub fn scoped_slice_sum(a: &[i32], b: &[i32]) -> (i32, i32) {
 /// In this exercise, the inner type is just `i32`, not a `Result`.
 #[allow(unused_variables)]
 pub fn handle_panic(value: i32, should_panic: bool) -> Result<i32, ()> {
-    // TODO: Spawn a thread that either panics or returns value
-    // TODO: Join and map the result appropriately
-    todo!()
+    // Spawn a thread that either panics or returns value
+    let handle = thread::spawn(move||{
+        if should_panic {
+            panic!("print to stderr");
+        }else {
+            value
+        }
+    });
+    // Join and map the result appropriately
+    match handle.join() {
+        Ok(result) => Ok(result),
+        Err(_) => Err(()),
+    }
 }
 
 #[cfg(test)]