美しいミズキ

1
## 高级线程操作
2
//! - **线程睡眠**：`thread::sleep` 暂停当前线程。
3
//! - **线程本地存储**：`thread_local!` 宏定义每个线程独有的静态变量。
4
//! - **线程命名**：`Builder::name` 为调试目的分配名称。
5
//! - **线程优先级**：通过 `thread::Builder` 设置（依赖平台）。
6
//! - **线程池**：像 `rayon` 这样的库管理线程复用。
7
//! - **线程通信**：使用 `std::sync::mpsc`（多生产者单消费者）或第三方 crate（例如 `crossbeam`）。
8
//! - **共享状态**：`Arc<Mutex<T>>` 或 `Arc<RwLock<T>>` 安全地在线程间共享可变数据。
9
//! - **同步原语**：`Barrier` 同步多个线程，`Condvar` 实现条件变量。
10
//! - **线程暂停与唤醒**：`thread::park` 阻塞线程，`unpark` 唤醒它，适用于自定义调度。
11
//! - **获取当前线程句柄**：`thread::current()`。
12
//! - **作用域线程**：`crossbeam::scope` 或标准库的 `thread::scope`（Rust 1.63+）允许线程借用栈上的数据而无需 `move`。
13
//!
14
//! Rust 通过所有权系统以及 `Send` 和 `Sync` trait 在编译时防止数据竞争。
15
//! 实现了 `Send` 的类型可以跨线程边界传递。
16
//! 实现了 `Sync` 的类型可以同时被多个线程引用。
17
//! 大多数 Rust 标准类型都是 `Send + Sync`；例外情况包括 `Rc<T>`（非原子引用计数）和裸指针。

1
let builder = thread::Builder::new()
2
         .name("my-worker".into())
3
         .stack_size(32 * 1024); // 32 KiB

1
use std::thread;
2

3
//假设线程不会创建失败
4

5
fn named_thread_example() {
6

7
   let builder = thread::Builder::new()
8

9
     .name("my-worker".into())//名字
10

11
     .stack_size(32 * 1024); // 32 KiB分配栈大小
12

13

14

15
   let handle = builder.spawn(|| {
16

17
     println!("Hello from thread: {:?}", thread::current().name());
18

19
     42
20

21
   }).unwrap();//spawn返回Result<JoinHandle<T>, io::Error>，unwrap()把JoinHandle传递给父进程
22

23

24

25
   let result = handle.join().unwrap();
26
    //handle.join()等待子进程结束，返回Result<T, Box<dyn Any + Send>>，如果创建成功，join()返回OK(42)，如果不成功，返回Err
27
    //unwrap()会导致当前线程panic
28

29
   println!("Thread returned: {}", result);
30
}

1
use std::thread;
2

3
 fn scoped_thread_example() {
4
     let a = vec![1, 2, 3];
5
     let b = vec![4, 5, 6];
6

7
     let (sum_a, sum_b) = thread::scope(|s| {
8
         let h1 = s.spawn(|| a.iter().sum::<i32>());//创建一个进程，必须在scope的作用域内销毁，可以引用局部变量。
9
         let h2 = s.spawn(|| b.iter().sum::<i32>());
10
         (h1.join().unwrap(), h2.join().unwrap())//直接提取join()的值，如果没有则报错
11
     });
12

13
     // `a` and `b` are still accessible here.
14
     println!("sum_a = {}, sum_b = {}", sum_a, sum_b);
15
}

1
fn f() {
2
    let x = 10;
3

4
    thread::spawn(|| {
5
        println!("{}", x); // 借用 x
6
    });
7

8
} // x 在这里销毁，但线程可能还没结束

1
use std::cell::RefCell;//RefCell的作用是：即使外面拿到的是不可变引用，也能在运行时进行可变借用
2
use std::thread;
3

4
thread_local! {//定义线性局部变量的宏
5
    static THREAD_ID: RefCell<usize> = RefCell::new(0);//每一个线程都有自己独立的THREAD_ID,初始值为0，static表示每个线程各自拥有的一份静态局部存储。
6
}
7

8
fn thread_local_example() {
9
    THREAD_ID.with(|id| {//调用函数访问线程的ID并且把它传给闭包使用，id是THREAD_ID的引用
10
        *id.borrow_mut() = 1;//borrow_mut() 会从 RefCell 里借出一个可变引用，*解引用把usize改成1
11
    });//主线程先把自己的THREAD_ID设为1
12

13
    let handle = thread::spawn(|| {//创建子进程
14
        THREAD_ID.with(|id| {
15
            *id.borrow_mut() = 2;
16
        });
17
        THREAD_ID.with(|id| println!("Thread local value: {}", *id.borrow()));//不可变引用的解引用
18
    });
19

20
    handle.join().unwrap();//正常结束拿出来值，panic则err
21

22
    THREAD_ID.with(|id| println!("Main thread value: {}", *id.borrow()));
23
}