12.3 线程安全与共享状态
在并发编程中，共享状态可能会导致数据竞争（Data Race），从而引发程序的不确定行为。Rust 的核心设计理念之一是通过编译时检查避免数据竞争。它提供了多种方式实现线程间共享状态的安全性，主要包括使用 Mutex 和 RwLock。
12.3.1 数据竞争的定义与 Rust 的解决方案
数据竞争
数据竞争通常发生在以下场景：
- 两个或多个线程同时访问相同的内存位置。
- 至少有一个线程尝试修改数据。
- 数据访问未被同步。
Rust 的解决方案
Rust 编译器通过所有权和借用规则，在编译时捕捉潜在的数据竞争问题。此外，Rust 提供了两种主要的同步工具：
Mutex（互斥锁）：保证同一时间只有一个线程能访问共享数据。RwLock（读写锁）：允许多个线程同时读数据，但只有一个线程可以写。
12.3.2 使用 Mutex 实现线程安全
Mutex（互斥锁）是 Rust 中最常用的同步工具。它通过确保同一时间只有一个线程可以访问共享数据来防止数据竞争。
示例：单线程使用 Mutex
1
2
3
4
5
6
7
8
9
10
11
12
|
use std::sync::Mutex;
fn main() {
let data = Mutex::new(5);
{
let mut data_guard = data.lock().unwrap(); // 获取锁
*data_guard += 1; // 修改数据
} // 释放锁
println!("Data: {:?}", data);
}
|
lock：尝试获取锁。如果锁已经被其他线程持有，则当前线程会阻塞。- 解锁：当
data_guard 超出作用域时，锁会自动释放。
示例：多线程使用 Mutex
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
let counter = Arc::new(Mutex::new(0)); // 使用 Arc 共享所有权
let mut handles = vec![];
for _ in 0..10 {
let counter_clone = Arc::clone(&counter);
let handle = thread::spawn(move || {
let mut num = counter_clone.lock().unwrap();
*num += 1;
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
println!("Final count: {}", *counter.lock().unwrap());
}
|
Arc：引用计数智能指针，用于在多线程间安全共享所有权。- 多线程锁：通过
Mutex 确保多个线程不会同时修改数据。
12.3.3 使用 RwLock 提升性能
RwLock（读写锁）允许多线程同时读共享数据，但在写数据时只能有一个线程拥有写权限。它适合读多写少的场景。
示例：使用 RwLock
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
|
use std::sync::{Arc, RwLock};
use std::thread;
fn main() {
let data = Arc::new(RwLock::new(5));
// 多线程读取数据
let data_clone = Arc::clone(&data);
let read_handle = thread::spawn(move || {
let read_guard = data_clone.read().unwrap();
println!("Read data: {}", *read_guard);
});
// 写入数据
let data_clone = Arc::clone(&data);
let write_handle = thread::spawn(move || {
let mut write_guard = data_clone.write().unwrap();
*write_guard += 1;
});
read_handle.join().unwrap();
write_handle.join().unwrap();
println!("Final data: {}", *data.read().unwrap());
}
|
read 和 write 方法：分别用于获取读锁和写锁。- 性能优势：在大量读操作时，
RwLock 比 Mutex 性能更优。
12.3.4 避免死锁
在使用锁的场景中，死锁可能会导致线程永久阻塞。Rust 的所有权机制虽然不能完全避免死锁，但可以帮助我们更轻松地识别潜在的死锁问题。
示例：死锁示例
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::{Arc, Mutex};
use std::thread;
fn main() {
let lock1 = Arc::new(Mutex::new(0));
let lock2 = Arc::new(Mutex::new(0));
let lock1_clone = Arc::clone(&lock1);
let lock2_clone = Arc::clone(&lock2);
let handle1 = thread::spawn(move || {
let _ = lock1_clone.lock().unwrap();
let _ = lock2_clone.lock().unwrap();
});
let lock1_clone = Arc::clone(&lock1);
let lock2_clone = Arc::clone(&lock2);
let handle2 = thread::spawn(move || {
let _ = lock2_clone.lock().unwrap();
let _ = lock1_clone.lock().unwrap();
});
handle1.join().unwrap();
handle2.join().unwrap();
}
|
解决方法：
- 确保所有锁的获取顺序一致。
- 尽量减少锁的持有时间。
12.3.5 其他线程安全工具
除了 Mutex 和 RwLock，Rust 还提供了其他工具来管理共享状态和实现线程安全。
原子操作
Atomic 类型：适用于简单的数据操作，例如计数器。- 示例：使用
AtomicUsize
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
use std::sync::atomic::{AtomicUsize, Ordering};
use std::thread;
fn main() {
let counter = AtomicUsize::new(0);
let handles: Vec<_> = (0..10)
.map(|_| {
thread::spawn(|| {
counter.fetch_add(1, Ordering::SeqCst);
})
})
.collect();
for handle in handles {
handle.join().unwrap();
}
println!("Counter: {}", counter.load(Ordering::SeqCst));
}
|
Condvar（条件变量）
Condvar 用于线程间的条件通知和等待，通常与 Mutex 一起使用。
12.3.6 小结
- Rust 提供了丰富的线程安全工具，例如
Mutex、RwLock 和 Atomic 类型。
- 使用这些工具可以避免数据竞争，安全地在多线程中共享状态。
- 在选择同步工具时，应根据具体需求权衡性能和易用性。
在下一章，我们将通过构建一个简单的命令行工具，综合运用 Rust 的语言特性与多线程能力，实现实际项目的开发。