数据竞争预防 ​

核心概念 ​

数据竞争(Data Race)是并发编程中最危险的问题之一。当两个或多个线程同时访问同一块内存,且至少有一个是写操作,并且没有同步机制时,就会发生数据竞争。数据竞争的后果是未定义行为——程序可能产生错误结果、崩溃、甚至出现安全漏洞。

Rust 通过所有权系统和借用规则,在编译期就从根本上消除了数据竞争的可能性。核心原理很简单:借用规则要求"别名 XOR 可变"(Aliasing XOR Mutability)——要么有多个只读引用,要么有一个可写引用,二者不能同时存在。这条规则在单线程中保证了引用安全,在多线程中天然地阻止了数据竞争。

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

    // 单线程中的"别名 XOR 可变"
    let r1 = &data;      // 别名(只读)
    let r2 = &data;      // 更多别名(只读)
    println!("{:?}, {:?}", r1, r2);
    // r1, r2 不再使用

    let r3 = &mut data;  // 可变(独占)
    r3.push(4);
    println!("{:?}", r3);

    // 这个规则自然延伸到多线程:
    // 如果多个线程想同时读写同一数据,编译器就会报错
}

数据竞争的三个条件 ​

数据竞争发生需要同时满足三个条件。Rust 的借用规则破坏了其中至少一个:

条件描述Rust 如何破坏
多个线程访问同一数据至少两个线程访问同一内存所有权保证数据只有一个所有者
至少一个是写操作至少有一个线程在修改数据&mut T 独占,不能和其他引用共存
没有同步机制访问没有被协调Mutex、RwLock 提供同步

Send 和 Sync Trait ​

Rust 用两个标记 trait 来控制类型在线程间的使用方式:

rust
use std::thread;

fn main() {
    // Send:类型的值可以安全地转移到另一个线程
    // 大多数类型都是 Send 的
    let data = String::from("hello");
    let handle = thread::spawn(move || {
        // data 的所有权被移动到新线程
        println!("线程中: {}", data);
    });
    handle.join().unwrap();

    // Sync:类型的引用可以安全地在多个线程间共享
    // 如果 T 是 Sync 的,那么 &T 可以安全地跨线程使用
    // 大多数类型都是 Sync 的

    // 不是 Send 的类型:Rc<T>
    // Rc 的引用计数不是原子操作,多线程访问会导致数据竞争
    // let rc = std::rc::Rc::new(5);
    // thread::spawn(move || {
    //     println!("{}", rc);  // 编译错误:Rc 不是 Send 的
    // });

    // 替代方案:Arc<T>(原子引用计数)
    let arc = std::sync::Arc::new(5);
    let arc_clone = arc.clone();
    let handle = thread::spawn(move || {
        println!("Arc 值: {}", arc_clone);
    });
    handle.join().unwrap();
    println!("主线程: {}", arc);
}
Trait含义不满足的类型
Send值可以安全地移动到另一个线程Rc<T>、裸指针
Sync引用可以安全地在多线程间共享Cell<T>、RefCell<T>、Rc<T>

所有权转移避免共享 ​

最简单的避免数据竞争的方式:把数据的所有权移动到另一个线程,移动后原线程不再拥有数据。

rust
use std::thread;

fn main() {
    let mut results = Vec::new();

    // 每个线程拥有自己的数据,没有共享
    for i in 0..5 {
        let handle = thread::spawn(move || {
            // 每个线程有自己的 i(Copy 类型,被复制)
            let result = i * i;
            println!("线程 {} 计算: {} * {} = {}", i, i, i, result);
            result
        });
        results.push(handle);
    }

    // 收集结果
    let values: Vec<i32> = results
        .into_iter()
        .map(|h| h.join().unwrap())
        .collect();
    println!("结果: {:?}", values);
}

Mutex 保护共享数据 ​

当多个线程确实需要访问同一数据时,使用 Mutex(互斥锁)来同步访问。

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

fn main() {
    // Arc<Mutex<T>>:多线程共享可变数据的标准模式
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for i in 0..10 {
        let counter = Arc::clone(&counter);  // 克隆 Arc(增加引用计数)
        let handle = thread::spawn(move || {
            // lock() 获取锁,返回 MutexGuard
            // MutexGuard 实现了 Deref,可以像使用 &mut T 一样使用
            let mut num = counter.lock().unwrap();
            *num += 1;
            println!("线程 {} 将计数器增加到 {}", i, *num);
            // MutexGuard 离开作用域时自动释放锁
        });
        handles.push(handle);
    }

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

    println!("最终计数: {}", *counter.lock().unwrap());
}

RwLock 读写锁 ​

RwLock 允许多个线程同时读取,但写入时独占——和 Rust 的借用规则(多读或一写)完全一致。

rust
use std::sync::{Arc, RwLock};
use std::thread;

fn main() {
    let data = Arc::new(RwLock::new(vec![1, 2, 3]));
    let mut handles = vec![];

    // 多个读取线程可以同时运行
    for i in 0..3 {
        let data = Arc::clone(&data);
        let handle = thread::spawn(move || {
            // read() 获取读锁,多个线程可以同时持有
            let values = data.read().unwrap();
            println!("读取线程 {}: {:?}", i, *values);
        });
        handles.push(handle);
    }

    // 写入线程需要独占
    {
        let data = Arc::clone(&data);
        let handle = thread::spawn(move || {
            // write() 获取写锁,独占访问
            let mut values = data.write().unwrap();
            values.push(4);
            values.push(5);
            println!("写入线程完成: {:?}", *values);
        });
        handles.push(handle);
    }

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

    println!("最终数据: {:?}", *data.read().unwrap());
}

通道传递数据 ​

通道(Channel)通过消息传递来避免共享状态,是另一种预防数据竞争的方式。

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

fn main() {
    // mpsc:多生产者单消费者通道
    let (tx, rx) = mpsc::channel();

    // 多个发送者
    for i in 0..5 {
        let tx = tx.clone();  // 克隆发送端
        thread::spawn(move || {
            let msg = format!("来自线程 {} 的消息", i);
            tx.send(msg).unwrap();  // 发送消息(所有权转移到通道)
            // msg 已被移动,不能再使用
        });
    }

    // 丢弃原始发送端,这样接收端在所有发送端关闭后会结束
    drop(tx);

    // 接收消息
    for received in rx {
        println!("收到: {}", received);
    }
}

基本示例 ​

用 Rust 的安全并发机制实现一个线程安全的计数器和日志系统:

rust
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;

struct SafeCounter {
    counts: Mutex<std::collections::HashMap<String, u64>>,
    log: Mutex<Vec<String>>,
}

impl SafeCounter {
    fn new() -> Self {
        SafeCounter {
            counts: Mutex::new(std::collections::HashMap::new()),
            log: Mutex::new(Vec::new()),
        }
    }

    // 增加指定键的计数
    fn increment(&self, key: &str) {
        let mut counts = self.counts.lock().unwrap();
        let count = counts.entry(key.to_string()).or_insert(0);
        *count += 1;

        let mut log = self.log.lock().unwrap();
        log.push(format!("{} -> {}", key, count));
    }

    // 获取指定键的计数
    fn get(&self, key: &str) -> u64 {
        let counts = self.counts.lock().unwrap();
        *counts.get(key).unwrap_or(&0)
    }

    // 获取所有计数
    fn all_counts(&self) -> Vec<(String, u64)> {
        let counts = self.counts.lock().unwrap();
        let mut result: Vec<(String, u64)> = counts
            .iter()
            .map(|(k, &v)| (k.clone(), v))
            .collect();
        result.sort_by_key(|(k, _)| k.clone());
        result
    }

    // 获取日志条目数
    fn log_count(&self) -> usize {
        self.log.lock().unwrap().len()
    }
}

fn main() {
    let counter = Arc::new(SafeCounter::new());
    let mut handles = vec![];

    // 多个线程同时操作计数器
    let categories = vec!["页面访问", "API调用", "错误", "页面访问", "API调用"];

    for (i, category) in categories.iter().enumerate() {
        let counter = Arc::clone(&counter);
        let cat = category.to_string();
        let handle = thread::spawn(move || {
            // 每个线程多次递增
            for _ in 0..100 {
                counter.increment(&cat);
            }
            println!("线程 {} 完成 ({} x100)", i, cat);
        });
        handles.push(handle);
    }

    // 等待所有线程完成
    for handle in handles {
        handle.join().unwrap();
    }

    // 输出结果
    println!("\n=== 统计结果 ===");
    for (key, count) in counter.all_counts() {
        println!("  {}: {}", key, count);
    }
    println!("  日志条目: {}", counter.log_count());

    // 验证:页面访问有 2 个线程各 100 次 = 200
    println!("\n页面访问: {} (预期 200)", counter.get("页面访问"));
    println!("API调用: {} (预期 200)", counter.get("API调用"));
    println!("错误: {} (预期 100)", counter.get("错误"));
}

常见问题 ​

问题一:Rust 真的能在编译期阻止所有数据竞争吗?

在安全 Rust(不使用 unsafe)中,是的。编译器通过所有权、借用规则、Send/Sync trait 三重保障,从编译期就阻止了数据竞争。使用 unsafe 时需要程序员自己保证安全。

问题二:Mutex 和 RwLock 怎么选?

类型读操作写操作适用场景
Mutex独占独占读写频率差不多
RwLock共享(多个读可并行)独占读多写少

问题三:为什么 Rc 不是 Send 的?

Rc 的引用计数用的是普通整数,不是原子操作。如果多个线程同时修改引用计数,就会产生数据竞争。Arc 用原子操作维护引用计数,所以是线程安全的。

问题四:死锁 Rust 能预防吗?

不能。Rust 能预防数据竞争但不能预防死锁。死锁是逻辑错误,需要程序员自己注意锁的获取顺序。

适用场景 ​

  • 多线程共享数据:用 Arc<Mutex<T>> 或 Arc<RwLock<T>>
  • 消息传递:用通道(mpsc)在线程间传递数据
  • 独占使用:用 move 闭包将数据所有权转移到线程
  • 无共享并行:每个线程处理独立的数据

注意事项 ​

  • Rust 在编译期阻止数据竞争,但不能阻止死锁
  • Send 表示值可以跨线程移动,Sync 表示引用可以跨线程共享
  • Rc<T> 不是线程安全的,多线程环境用 Arc<T>
  • Cell/RefCell 不是线程安全的,多线程环境用 Mutex/RwLock
  • Mutex::lock() 返回 MutexGuard,离开作用域自动释放锁
  • 尽量缩小锁的持有范围,减少锁竞争
  • 通道(消息传递)可以完全避免共享状态

总结 ​

Rust 通过所有权系统和借用规则在编译期从根本上消除了数据竞争。核心原理是"别名 XOR 可变"——多个只读引用可以共存,但可变引用必须独占。这个规则自然地延伸到多线程:Send 和 Sync trait 控制类型在线程间的使用方式,Rc 等非线程安全类型无法跨线程使用。当多个线程需要共享可变数据时,Mutex 和 RwLock 提供了同步机制,通道(mpsc)提供了消息传递方式。Rust 的安全并发保证覆盖了编译期能检测的所有数据竞争场景,但死锁等逻辑问题仍需程序员自行避免。