消息传递

实例

  1. use std::sync::mpsc;
  2. use std::thread;
  4. // 使用通道在多个线程中传递消息
  6. fn main() {
  7.     let (tx, rx) = mpsc::channel();
  9.     thread::spawn(move || {
  10.         // send 函数会获取其参数的所有权
  11.         // 并移动这个值归接收者所有
  13.         let v = vec![7, 8, 9];
  14.         for i in v {
  15.             tx.send(i).unwrap();
  16.         }
  17.     });
  18.     let recver = thread::spawn(move || {
  19.         // 使用迭代方式从通道中取值
  20.         for i in rx {
  21.             println!("{}", i);
  22.         }
  23.     });
  24.     recver.join().unwrap();
  25. }

共享状态

使用互斥器（Mutex）来保护数据，每次访问数据需要获取所锁：
Mutex<T>是一个智能指针
lock()调用 返回 一个叫做 MutexGuard 的智能指针， 这个智能指针实现了Deref来指向其内部数据；其也提供了一个Drop实现当MutexGuard离开作用域时自动释放锁

结合Arc

它是一个原子引用计数（atomically reference counted）类型

适用于多线程场景

和Rc<T>对比：

Arc<T>对应Rc<T>，提供引用计数功能
Mutex<T>对应RefCell<T>，提供内部可变性功能

实例

  1. use std::{
  2.     sync::{Arc, Mutex},
  3.     thread::{self, JoinHandle},
  4. };
  6. // 使用mutex在多线程中共享数据
  8. fn main() {
  9.     // 创建具有多所有权的互斥器
  10.     let m = Arc::new(Mutex::new(0));
  11.     // 存放线程的handle
  12.     let mut handles: Vec<JoinHandle<()>> = Vec::new();
  14.     for _ in 0..10 {
  15.         let counter = m.clone();
  16.         // 在单独的线程中对互斥器进行修改
  17.         let handle = thread::spawn(move || {
  18.             // 调用 lock 后返回的是 MutexGuard 类型的智能指针
  19.             // 来访问内部数据
  20.             // 类似于 RefCell, 提供了内部可变性
  21.             let mut num = counter.lock().unwrap();
  22.             *num += 1;
  23.         });
  25.         handles.push(handle);
  26.     }
  28.     for handle in handles {
  29.         handle.join().unwrap();
  30.     }
  32.     println!("{:?}", *m.lock().unwrap());
  33. }

Send，Sync trait

Send

Send标记trait表明类型的所有权可以在线程间传递。

几乎所有的Rust类型都是Send的，但是Rc<T>是不能Send的，这两个线程都可能同时更新引用计数。

任何完全由Send的类型组成的类型也会自动被标记为Send。

几乎所有基本类型都是Send的，除了裸指针（raw pointer）。

Sync

Sync标记trait表明一个实现了Sync的类型可以安全的在多个线程中拥有其值的引用。

如果&T（T的引用）是Send的话T就是Sync的，这意味着其引用就可以安全的发送到另一个线程

基本类型是Sync的，完全由Sync的类型组成的类型也是Sync的。

实例

直接往std::thread::spawn()里面传引用会报错：borrowed value does not live long enough

这里使用crossbeam库，不过需要多套一层thread::scope：

  1. use crossbeam::thread;
  3. fn main() {
  4.     let mut greeting = String::from("Hello");
  5.     let greeting_ref = &greeting;
  7.     thread::scope(|scoped_thread| {
  8.         // spawn 3 threads
  9.         for n in 1..=3 {
  10.             // greeting_ref copied into every thread
  11.             scoped_thread.spawn(move |_| {
  12.                 println!("{} {}", greeting_ref, n); // prints "Hello {n}"
  13.             });
  14.         }
  16.         // line below could cause UB or data races but compiler rejects it
  17.         // greeting += " world"; // ❌ cannot mutate greeting while immutable refs exist
  18.     });
  20.     // can mutate greeting after every thread has joined
  21.     greeting += " world"; // ✅
  22.     println!("{}", greeting); // prints "Hello world"
  23. }