Rust 编程语言 - 无畏并发 - 搬砖程序员带你飞

lpflpf 收录于学习笔记

2023-03-09 约 800 字预计阅读 2 分钟

使用线程同时运行代码

多线程会遇到的问题：

竞态条件
死锁
只在特定条件下发生，难以复现和修复的bug

rust 标准库使用1:1实现线程。一个语言级别的线程对应一个操作系统线程

创建线程

使用 thread::spawn创建线程

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


use std::thread;
use std::time::Duration;

fn main() {
    // 闭包方法创建线程
    thread::spawn(|| {
        for i in 1..10 {
            println!("hi number {} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 1..5 {
        println!("hi number {} from the main thread!", i);
        thread::sleep(Duration::from_millis(1));
    }
}

等待线程终止

使用 join 方法等待线程终止

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


use std::thread;
use std::time::Duration;

fn main() {
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("hi number {} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

// 等待线程结束后执行main方法 
    handle.join().unwrap();
    for i in 1..5 {
        println!("hi number {} from the main thread!", i);
        thread::sleep(Duration::from_millis(1));
    }

}

传递参数

使用move 关键字，强制将依赖的参数的所有权交给线程内部

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


use std::thread;

fn main() {
    let v = vec![1, 2, 3];

    let handle = thread::spawn(move || {
        println!("Here's a vector: {:?}", v);
    });

    handle.join().unwrap();
}

使用消息传递

go 思想:不要通过共享内存来通讯；而是通过通讯来共享内存。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


use std::sync::mpsc;
use std::thread;

// mpsc 产出可以支持多个生产者，一个消费者
fn main() {
    let (tx, rx) = mpsc::channel();

    // rx 可以通过clone 实现多个生产者
    thread::spawn(move || {
        let val = String::from("hi");
        // tx 是生产端
        tx.send(val).unwrap();

        // 之后val 不可再被使用，所有权被移动到接收者
    });

    // 接收端 阻塞接收
    // rx.try_recv 非阻塞接收
    let received = rx.recv().unwrap();
    println!("Got: {}", received);

    // 迭代器接收
    // for received in rx {
    //     println!("Got: {}", received);
    // }
}

共享状态

互斥锁

使用规则：

在使用数据之前尝试获取锁
处理完被互斥器所保护的数据之后，必须解锁数据

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


use std::sync::{Arc, Mutex};
use std::sync::Mutex;
use std::thread;

fn main() {
    // 使用Arc 使用多线程安全的多所有权
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Rc::clone(&counter);
        let handle = thread::spawn(move || {
        // 阻塞调用，直到拿到锁
            let mut num = counter.lock().unwrap();

            *num += 1;
        // 包含drop 方法，离开作用域自动释放锁
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {}", *counter.lock().unwrap());
}

Rust 程序设计语言: 无畏并发

Rust 编程语言 - 无畏并发