《Rust编程实战》6.2 同步原语应用

6.2 同步原语应用

在多线程编程中，同步原语用于协调线程间的操作，确保共享资源的正确访问。Rust 提供了多种高效的同步原语，例如 Mutex、RwLock、Condvar 和 Barrier，帮助开发者构建线程安全的并发程序。

本节将深入探讨这些同步原语的使用场景、优势及其典型应用方式，并附上代码示例。

6.2.1 Mutex：互斥锁

Mutex 是最基础的同步原语，用于确保同一时刻只有一个线程可以访问共享资源。

使用场景
  • 当资源需要可变访问且可能被多个线程同时修改时，使用 Mutex 确保互斥访问。
示例：简单的互斥锁
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

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

fn main() {
    let data = Arc::new(Mutex::new(0));

    let mut handles = vec![];
    for _ in 0..10 {
        let data_clone = Arc::clone(&data);
        handles.push(thread::spawn(move || {
            let mut num = data_clone.lock().unwrap();
            *num += 1; // 互斥锁保证此处的修改是线程安全的
        }));
    }

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

    println!("Final value: {}", *data.lock().unwrap()); // 输出: Final value: 10
}
注意事项
  1. 死锁：如果线程尝试多次锁定 Mutex 或锁定顺序不一致，可能导致死锁。
  2. 阻塞：Mutex 的 lock 操作是阻塞的，如果长期持有锁，可能导致性能下降。

6.2.2 RwLock：读写锁

RwLock 提供了读写分离的机制：

  • 允许多个线程同时读取数据。
  • 写操作独占锁，防止数据竞争。
使用场景
  • 当资源读多写少时，RwLock 比 Mutex 更高效。
示例：读写分离的锁
 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, RwLock};
use std::thread;

fn main() {
    let data = Arc::new(RwLock::new(0));

    let mut handles = vec![];
    for _ in 0..5 {
        let data_clone = Arc::clone(&data);
        handles.push(thread::spawn(move || {
            let read_value = *data_clone.read().unwrap();
            println!("Read value: {}", read_value);
        }));
    }

    let data_clone = Arc::clone(&data);
    handles.push(thread::spawn(move || {
        let mut write_value = data_clone.write().unwrap();
        *write_value += 1; // 独占写
    }));

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

    println!("Final value: {}", *data.read().unwrap()); // 输出: Final value: 1
}
注意事项
  1. 写操作可能阻塞正在等待的读操作。
  2. 不适合频繁的读写切换场景，可能导致锁竞争。

6.2.3 Condvar：条件变量

Condvar（条件变量）用于线程间的信号通知，通常与 Mutex 搭配使用。它允许一个线程等待某个条件满足，同时让其他线程通知条件已满足。

使用场景
  • 实现线程间的等待和唤醒机制。
  • 在某些条件满足前阻塞线程。
示例：生产者-消费者模型
 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, Condvar, Mutex};
use std::thread;

fn main() {
    let pair = Arc::new((Mutex::new(false), Condvar::new()));

    let pair_clone = Arc::clone(&pair);
    let producer = thread::spawn(move || {
        let (lock, cvar) = &*pair_clone;
        let mut started = lock.lock().unwrap();
        *started = true;
        cvar.notify_one(); // 通知消费者
    });

    let pair_clone = Arc::clone(&pair);
    let consumer = thread::spawn(move || {
        let (lock, cvar) = &*pair_clone;
        let mut started = lock.lock().unwrap();
        while !*started {
            started = cvar.wait(started).unwrap(); // 等待条件满足
        }
        println!("Condition met, proceeding...");
    });

    producer.join().unwrap();
    consumer.join().unwrap();
}

6.2.4 Barrier：线程栅栏

Barrier 用于同步多个线程的执行进度。只有所有线程都到达栅栏时，才能继续执行。

使用场景
  • 用于阶段性同步，例如并行计算中的分步执行。
示例：线程同步
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

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

fn main() {
    let barrier = Arc::new(Barrier::new(3));
    let mut handles = vec![];

    for i in 0..3 {
        let barrier_clone = Arc::clone(&barrier);
        handles.push(thread::spawn(move || {
            println!("Thread {} before barrier", i);
            barrier_clone.wait(); // 等待其他线程到达
            println!("Thread {} after barrier", i);
        }));
    }

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

6.2.5 同步原语的选择

原语 适用场景 优势 注意事项
Mutex 需要独占访问的共享资源 易用，适合基础互斥需求 可能导致死锁和阻塞
RwLock 读多写少的场景 高效的读写分离 读写切换可能存在竞争
Condvar 线程间等待和通知 实现复杂的同步逻辑 需要与 Mutex 搭配
Barrier 多线程同步点，例如阶段性任务 简化多线程的同步逻辑 所有线程必须到达

总结

Rust 提供了一套功能强大的同步原语，使开发者能够以安全高效的方式处理多线程场景。通过选择合适的同步原语，结合 Rust 的类型系统和所有权模型，可以避免常见的并发问题（如数据竞争和死锁）。同时，开发者需要注意使用场景和性能权衡，以确保实现最优的并发代码设计。