数据竞争预防
核心概念
数据竞争(Data Race)是并发编程中最危险的问题之一。当两个或多个线程同时访问同一块内存,且至少有一个是写操作,并且没有同步机制时,就会发生数据竞争。数据竞争的后果是未定义行为——程序可能产生错误结果、崩溃、甚至出现安全漏洞。
Rust 通过所有权系统和借用规则,在编译期就从根本上消除了数据竞争的可能性。核心原理很简单:借用规则要求"别名 XOR 可变"(Aliasing XOR Mutability)——要么有多个只读引用,要么有一个可写引用,二者不能同时存在。这条规则在单线程中保证了引用安全,在多线程中天然地阻止了数据竞争。
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 来控制类型在线程间的使用方式:
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> |
所有权转移避免共享
最简单的避免数据竞争的方式:把数据的所有权移动到另一个线程,移动后原线程不再拥有数据。
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(互斥锁)来同步访问。
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 的借用规则(多读或一写)完全一致。
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)通过消息传递来避免共享状态,是另一种预防数据竞争的方式。
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 的安全并发机制实现一个线程安全的计数器和日志系统:
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/RwLockMutex::lock()返回MutexGuard,离开作用域自动释放锁- 尽量缩小锁的持有范围,减少锁竞争
- 通道(消息传递)可以完全避免共享状态
总结
Rust 通过所有权系统和借用规则在编译期从根本上消除了数据竞争。核心原理是"别名 XOR 可变"——多个只读引用可以共存,但可变引用必须独占。这个规则自然地延伸到多线程:Send 和 Sync trait 控制类型在线程间的使用方式,Rc 等非线程安全类型无法跨线程使用。当多个线程需要共享可变数据时,Mutex 和 RwLock 提供了同步机制,通道(mpsc)提供了消息传递方式。Rust 的安全并发保证覆盖了编译期能检测的所有数据竞争场景,但死锁等逻辑问题仍需程序员自行避免。