并发是很多编程语言避不开的一块主要内容,主打一个无畏并发的Rust
自然也面临这样的挑战。Rust
中的Mutex
提供了强大的同步原语,确保共享数据的线程安全,这篇文章中,我们会探讨Mutex
的使用,从基础的用法到一些高阶内容。
1. Rust
中的互斥锁
Mutex
作为Rust
中的一种互斥锁,它一次只允许一个线程访问共享资源。
-
提供了一种同步可变数据访问的机制,防止数据竞争、确保线程安全;
-
位于
Rust
标准库std::sync::Mutex
中,支持对共享可变状态的安全并发访问。 -
互斥锁允许一个线程在访问共享数据时获取锁,而其他线程必须等待该线程释放锁后才能访问共享数据,从而确保数据的安全性和一致性。
2. 基本用法体验
下面以使用
Mutex
保护共享数据为例演示Mutex
的基础用法。
use std::{sync::Mutex, thread};
fn main() {let counter = Mutex::new(0);let handle = thread::spawn(move || {let mut value = counter.lock().unwrap();*value += 1;});handle.join().expect("thread panicked!");let value = counter.lock().unwrap();println!("Counter:{}", *value);
}
这段代码演示了
Mutex
的基本用法,但它是无法通过编译的,尽管如此,这里还是对上述代码进行解释一下:
-
let counter = Mutex::new(0);
- 在这行代码中,创建了一个名为
counter
的Mutex
,其中包含一个整数值初始为 0。这个Mutex
将用于保护共享的整数值,以确保线程安全访问。
- 在这行代码中,创建了一个名为
-
let handle = thread::spawn(move || { ... });
- 使用
thread::spawn
创建一个新线程,并在该线程中执行一个闭包。这个闭包中的内容将在新线程中运行。 move
关键字用于将counter
的所有权转移给闭包,确保闭包可以在新线程中使用counter
。
- 使用
-
let mut val = counter.lock().unwrap();
- 在闭包中,通过调用
lock()
方法获取counter
的锁,并使用unwrap()
处理可能的锁获取失败的情况。这里的val
是一个MutexGuard
,它允许我们安全地访问被Mutex
保护的数据。
- 在闭包中,通过调用
-
*val += 1;
- 在获取了
counter
的锁之后,对共享数据进行递增操作。
- 在获取了
-
handle.join().expect("thread panicked!");
- 等待新线程执行完毕。
join()
方法会阻塞当前线程,直到新线程执行完毕。 - 如果新线程发生了 panic,
expect()
方法会打印指定的错误信息。
- 等待新线程执行完毕。
-
let val = counter.lock().unwrap();
- 在主线程中,再次获取
counter
的锁,以确保安全地访问共享数据。
- 在主线程中,再次获取
-
println!("Counter:{}", *val);
- 打印最终的共享数据值。
那么问题来了,为什么无法通过编译:
在这段代码在编译阶段会出现 borrow of moved value 的错误,因为我们在
thread::spawn
的闭包中移动了counter
,而后又在闭包外部尝试再次使用它。为了解决这个问题,我们需要使用
Arc
(原子引用计数) 来在多线程之间安全地共享counter
。
use std::{sync::{Arc, Mutex},thread,
};
fn main() {let counter = Arc::new(Mutex::new(0));let counter_clone = Arc::clone(&counter);let handle = thread::spawn(move || {let mut value = counter_clone.lock().unwrap();*value += 1;});match handle.join() {Ok(_) => {let value = counter.lock().unwrap();println!("Counter: {}", *value);}Err(_) => {println!("Thread panicked!");}}
}
修复之后的代码中,使用了Arc
对mutex
进行了调整,通过使用 Arc
来创建一个引用计数的 Mutex
,并在闭包中使用 Arc
的克隆。这样可以确保在多线程环境中安全地共享 counter
,避免了 borrow of moved value 的问题。同时使用match
表达式进一步对错误进行了处理。
3. 多个锁的使用
有时,我们可能需要独立保护多个共享资源。 Rust 允许您使用多个锁来实现这一点:
use std::{sync::{Arc, Mutex},thread,
};fn main() {let cnt1 = Arc::new(Mutex::new(0));let cnt2 = Arc::new(Mutex::new(0));let cnt1_clone = Arc::clone(&cnt1);let handle1 = thread::spawn(move || {let mut value = cnt1_clone.lock().unwrap();*value += 1;});let cnt2_clone = Arc::clone(&cnt2);let handle2 = thread::spawn(move || {let mut value2 = cnt2_clone.lock().unwrap();*value2 += 1;});match handle1.join() {Ok(_) => {let value1 = cnt1.lock().unwrap();println!("cnt1:{}", *value1);}Err(_) => {println!("Thread panicked!");}}match handle2.join() {Ok(_) => {let value2 = cnt2.lock().unwrap();println!("cnt2:{}", *value2);}Err(_) => {println!("Thread panicked!");}}
}
这段代码演示了如何使用
Arc
和Mutex
在 Rust 中实现多线程并发访问共享数据:
首先,通过
use
关键字引入了需要使用的标准库中的一些模块,包括Arc
、Mutex
和thread
。在
main
函数中,创建了两个计数器cnt1
和cnt2
,它们分别被包装在Arc
和Mutex
中。这样做是为了确保在多线程环境中安全地访问这两个计数器。使用
Arc::clone(&cnt1)
和Arc::clone(&cnt2)
创建了两个Arc
的克隆,分别赋值给cnt1_clone
和cnt2_clone
。这样做是为了将计数器的所有权移动到新的线程中。通过
thread::spawn
创建了两个线程handle1
和handle2
,分别对cnt1_clone
和cnt2_clone
所指向的计数器进行操作。在每个线程中,首先获取了计数器的锁,然后对计数器的值进行加一操作。使用
handle1.join()
和handle2.join()
分别等待两个线程的执行结果。如果线程执行成功,就获取相应计数器的锁并打印计数器的值;如果线程执行失败(比如发生了 panic),则打印出相应的错误信息。