• 并发（Concurrent）：程序的不同部分相互独立执行
  • 并行（Parallel）：程序不同部分同时执行

1 线程

1.1 基本使用

  1. use std::thread;
  2. use std::time::Duration;
  4. fn main() {
  5.     let handle = thread::spawn(|| {
  6.         for i in 1..10 {
  7.             println!("hi number {} from the spawned thread!", i);
  8.             thread::sleep(Duration::from_millis(1));
  9.         }
  10.     });
  12.     for i in 1..5 {
  13.         println!("hi number {} from the main thread!", i);
  14.         thread::sleep(Duration::from_millis(1));
  15.     }
  17.     handle.join().unwrap();
  18. }
  • thread::spawn()在创建线程失败时会panic，可以用std::thread::Builder::spawn()来创建线程，失败时不会panic
  • thread::sleep()、thread::sleep_ms()、thread::yield_now()
  • thread::current()、thread::park/unpark()（暂停/恢复）

    1.2 对闭包使用move

  1. use std::thread;
  3. fn main() {
  4.     let v = vec![1, 2, 3];
  5.     // 编译通不过：闭包的生存周期可能超过本函数,但是却借用了属于本函数的变量 v
  6.     // let handle = thread::spawn(|| {
  7.     // 通过关键字 move，指示将借用的变量的所有权转移到闭包中，闭包外面变量 v 已经失效，不得再使用
  8.     let handle = thread::spawn(move || {
  9.         println!("Here's a vector: {:?}", v);
  10.     });
  11.     //drop(v);// 即使没有这一句也编译通不过: 这一句只是说明,可能 v 已经失效，但是执行闭包的线程仍然借用着 v，这是不允许的
  12.     handle.join().unwrap();
  13. }

2 通道

2.1 基本使用

  1. use std::thread;
  2. use std::sync::mpsc;
  4. pub fn main() {
  5.     let (tx, rx) = mpsc::channel();
  7.     thread::spawn(move || {
  8.         let val = String::from("hi");
  9.         tx.send(val).unwrap();
  10.     });
  12.     let received = rx.recv().unwrap();
  13.     println!("Got: {}", received);
  14. }
  • mpsc表示多个生产者、单个消费者
  • 接收方法：recv、try_recv、recv_timeout、recv_deadline、iter、try_iter
  • 发送端退出后，接收方将返回错误：但通道是缓冲的，发送端退出前发送的所有消息，接收方都可以接收
  • 不存在接收方时，发送将失败；存在接收方时，发送一定成功：系统会缓存发送的内容，不限制缓存数量
  • 被发送内容的所有权将转移到发送方法中!!!
  • 异步通道：mpsc::channel()，缓存数量无上限
  • 同步通道：mpsc::sync_channel()，必须指定一个缓存数量上限，通道满时发送方发送操作将阻塞；

  • 同步通道可以指定缓存数量上限为零

    2.2 使用多个发送端

  • 调用发送方的clone方法可以克隆出一个新的发送端，多个发送端可以并发工作

  1. pub fn main2() {
  2.     let (tx, rx) = mpsc::channel();
  4.     let tx1 = mpsc::Sender::clone(&tx);
  5.     // 这样写也是正确的
  6.     // let tx1 = tx.clone();
  7.     thread::spawn(move || {
  8.         let vals = vec![
  9.             String::from("hi"),
  10.             String::from("from"),
  11.             String::from("the"),
  12.             String::from("thread"),
  13.         ];
  15.         for val in vals {
  16.             tx1.send(val).unwrap();
  17.             thread::sleep(Duration::from_secs(1));
  18.         }
  19.     });
  21.     thread::spawn(move || {
  22.         let vals = vec![
  23.             String::from("more"),
  24.             String::from("messages"),
  25.             String::from("for"),
  26.             String::from("you"),
  27.         ];
  29.         for val in vals {
  30.             tx.send(val).unwrap();
  31.             thread::sleep(Duration::from_secs(1));
  32.         }
  33.     });
  35.     for received in rx {
  36.         println!("Got: {}", received);
  37.     }
  38. }

3 共享状态

3.1 Mutex<T>

  1. use std::sync::Mutex;
  3. fn main() {
  4.     let m = Mutex::new(5);
  5.     {
  6.         let mut num = m.lock().unwrap();
  7.         *num = 6;
  8.     }
  9.     println!("m = {:?}", m);
  10. }
  • 创建：Mutex::new()，这是一个泛型关联方法，可封装任意类型
  • 获取封装的资源
    • lock()：可能会阻塞，直到正确获取到锁，此时返回MutexGuard类型的值，MutexGuard离开作用域时自动开锁
    • 还可能不会阻塞，返回PoisonError，也就是锁被抛弃（拥有锁的线程发生panic，没有正常开锁），被锁保护的资源可能处于不一致状态，不应该使用
    • 用is_poisoned()判断锁是否被抛弃
    • try_lock()：不会阻塞，可能的返回值有：(1) 正常，返回MutexGuard (2) WouldBlock，已经锁定，无法获取锁 (3) Poisoned，锁被抛弃

      3.2 用Arc<T>封装Mutex<T>以便在多个线程中使用

  1. use std::sync::{Mutex, Arc};
  2. use std::thread;
  4. fn main() {
  5.     let counter = Arc::new(Mutex::new(0));// 用 Arc<T> 封装 Mutex<T>
  6.     let mut handles = vec![];
  8.     for _ in 0..10 {
  9.         let counter = Arc::clone(&counter);// 克隆
  10.         let handle = thread::spawn(move || {
  11.             let mut num = counter.lock().unwrap();// Mutex<T> 实现了内部可变性，通过不可变的 counter 可以改变内部封装的值
  12.             *num += 1;
  13.         });
  14.         handles.push(handle);
  15.     }
  17.     for handle in handles {
  18.         handle.join().unwrap();
  19.     }
  21.     println!("Result: {}", *counter.lock().unwrap());
  22. }