而 MutexGuard 类型则是一个“智能指针”类型,它实现了DerefMut 和 Deref 这 两 个 trait,所以它可以被当作指向内部数据的普通指针使用。 MutexGuard 实现了一个析构函 数,通过RAII手法,在析构函数中调用了unlock()方法解锁。因此,用户是不需要手动 调用方法解锁的。

Rust 的这个设计,优点不在于它“允许你做什么”,而在于它“不允许你做什么”。 如 果我们误用了Rc来实现线程之间的共享,就是编译错误。根据编译错误,我们将 指针改为Arc 类型,然后又会发现,它根本没有提供可变性。它的API 只能共享读,根本 没有写数据的方法存在。此时,我们会想到加入内部可变性来允许多线程共享读写。如果我 们使用了Arc<RefCell<>>类型,依然是编译错误。因为RefCell 类型不满足 Sync。 而 Arc 需要内部的T 参数必须满足T:Sync,才 能 使Arc满 足Sync 。 把这些综合起 来,我们可以推理出Arc<RefCell<>>是 !Sync。
最终,编译器把其他的路都堵死了,唯一可以编译通过的就是使用那些满足 Sync条 件 的类型,比如Arc<Mutex<_>> 。在使用的时候,我们也不可能忘记调用lock方法,因为 Mutex 把真实数据包裹起来了,只有调用lock方法才有机会访问内部数据。我们也不需要 记得调用unlock方法,因为 lock方法返回的是一个MutexGuard类型,这个类型在析 构的时候会自动调用unlock。
所以,编译器在逼着用户用正确的方式写代码。
RwLock
RwLock 就是“读写锁”。它跟Mutex 很像,主要区别是对外暴露的API 不 一样。对Mutex内部的数据读写, RwLock 都是调用同样的lock 方法;而对RwLock 内部的数据读写,它分别提供了一个成员方法read/write来做这个事情。其他方面基本和Mutex一致。示例如下:
use std: :sync: :Arc;
use std: :sync: :RwLock;
use std: :thread;
const COUNT: u32 = 1000000;
fn main() {
let global = Arc: :new(RwLock: :new(0));
let clonel = global.clone();
let thread1 = thread: :spawn(move | l {
for_in 0..COUNT {
let mut value = clone1.write().unwrap(); * value += 1;
}
});
let clone2 = global.clone();
let thread2 = thread: :spawn(move | l {
for_in 0..COUNT {
let mut value = clone2.write().unwrap(); * value -= 1;
}
});
thread1.join().ok();
thread2.join().ok();
println ! ("final value:{:?}", global);
}
Atomic
Rust 标准库还为我们提供了一系列的“原子操作”数据类型,它们在std::sync::atomic模块里面。它们都是符合 Sync的,可以在多线程之间共享。比如,我们有 AtomicIsize类型,顾名思义,它对应的是isize类型的“线程安全”版本。我们知道, 普通的整数读取再写入,这种操作是非原子的。而原子整数的特点是,可以把“读取”“计 算”“再写入”这样的操作编译为特殊的CPU 指令,保证这个过程是原子操作。
我们来看一个示例:
use std: :sync: :Arc;
use std: :sync: :atomic: :{
AtomicIsize,
Ordering
};
use std: :thread;
const COUNT: u32 = 1000000;
fn main() {
//Atomic 系列类型同样提供了线程安全版本的内部可变性
let global = Arc: :new(AtomicIsize: :new(0));
let clone1 = global.clone();
let thread1 = thread: :spawn(move || {
for_in 0..COUNT {
clone1.fetch_add(1, Ordering: :SeqCst);
}
});
let clone2 = global.clone();
let thread2 = thread: :spawn(move || {
for_in 0..COUNT {
clone2.fetch_sub(1, Ordering: :SeqCst);
}
});
thread1.join().ok();
thread2.join().ok();
println ! ("final value:{:?}", global);
}
这个示例我们很熟悉:两个线程修改同一个整数, 一个线程对它进行多次加1,另外一 个线程对它多次减1。这次我们发现,使用了Atomic 类型后,我们可以保证最后的执行结果 一 定 会 回 到 0 。
我们还可以把这段代码改动 一 下:
use std: :sync: :Arc;
use std: :sync: :atomic: :{
AtomicIsize,
Ordering
};
use std: :thread;
const COUNT: u32 = 1000000;
fn main() {
let global = Arc: :new(AtomicIsize: :new(0));
let clone1 = global.clone();
let thread1 = thread: :spawn(move || {
for_in 0..COUNT {
let mut value = clone1.load(Ordering: :SeqCst);
value += 1;
clone1.store(value, Ordering: :SeqCst);
}
});
let clone2 = global.clone();
let thread2 = thread: :spawn(move || {
for_in 0..COUNT {
let mut value = clone2.load(Ordering: :SeqCst);
value -= 1;
clone2.store(value, Ordering: :SeqCst);
}
});
thread1.join().ok();
thread2.join().ok();
println ! ("final value:{:?}", global);
}
与上一个版本相比,这段代码的区别在于:我们没有使用原子类型自己提供的 fetch_add fetch_sub方法,而是使用了load 把里面的值读取出来,然后执行加/减,操作完成后,再用store存储回去。编译程序我们看到,是可以编译通过的。再执行,出现了问 题:这次的执行结果就不是保证为0了。
大家应该很容易看明白问题在哪里。原来的那种写法,“读取/计算/写入”是一个完整 的“原子操作”,中间不可被打断,它是 一 个“事务”(transaction)。 而后面的写法把“读取” 作为了一个“原子操作”,“写入”又作为了一个“原子操作”,把一个transaction 分成了两 段来执行。上面的那个程序,其逻辑类似于"lock=> 读数据=>加/减运算=>写数据=> unlock” 。 下面的程序,其逻辑类似于 “lock => 读数据=>unlock =>加/减运算=>lock => 写数据=>unlock” 。 虽然每次读写共享变量都保证了唯一性,但逻辑还是错的。
所以,编译器只能防止基本的数据竞争问题。如果程序里面有逻辑错误,工具是没有办 法帮我们发现的。上面这个示例中并不存在数据竞争问题,是完全的“业务逻辑 bug”。
死锁
既 然Rust 中提供了“锁”机制,那么Rust 中是否有可能出现“死锁”的现象呢?我们 用经典的“哲学家就餐问题”来演示一下。
问题:假设有5个哲学家,共享一张放有5把椅子的桌子,每人分得一把椅子,但是, 桌子上共有5支筷子,在每人两边各放一支,哲学家们在肚子饥饿时才试图分两次从两边拿 起筷子就餐 。
条 件 :
- 拿到两支筷子时哲学家才开始吃饭;
- 如果筷子已在他人手上,则该哲学家必须等他人吃完之后才能拿到筷子;
- 任一哲学家在自己未拿到两只筷子前却不放下自己手中的筷子。
代码如下 :
use std: :thread;
use std: :sync: :{
Mutex,
Arc
};
use std: :time: :Duration;
struct Philosopher {
name: String,
left: usize,
right: usize,
}
impl Philosopher {
fn new(name: &str, left: usize, right: usize) - >Philosopher {
Philosopher {
name: name.to_string(),
left: left,
right: right,
}
}
fn eat( & self, table: &Table) {
let _left = table.forks[self.left].lock().unwrap();
println ! ("{}take left fork.", self.name);
thread: :sleep(Duration: :from_secs(2));
let _right = table.forks[self.right].lock().unwrap();
println ! ("{}take right fork.", self.name);
thread: :sleep(Duration: :from_secs(1));
println ! ("{}is done eating.", self.name);
}
}
struct Table {
forks: Vec < Mutex < () >> ,
}
fn main() {
let table = Arc: :new(Table {
forks: vec ! [Mutex: :new(()), Mutex: :new(()), Mutex: :new(()), Mutex: :new(()), Mutex: :new(()), ]
});
let philosophers = vec ! [Philosopher: :new("Judith Butler", 0, 1), Philosopher: :new("Gilles Deleuze", 1, 2), Philosopher: :new("Karl Marx", 2, 3), Philosopher: :new("Emma Goldman", 3, 4), Philosopher: :new("Michel Foucault", 4, 0), ];
let handles: Vec < _ >= philosophers.into_iter().map(Ipl {
let table = table.clone();
thread: :spawn(move | l {
p.eat( & table);
})
}).collect();
for h in handles {
h.join().unwrap();
}
}
编译执行,我们可以发现,5个哲学家都拿到了他左边的那支筷子,而都在等待他右边 的那支筷子。在没等到右边筷子的时候,每个人都不会释放自己已经拿到的那支筷子。于 是,大家都进入了无限的等待之中,程序无法继续执行了。这就是“死锁”。
在 Rust 中,“死锁”问题是没有办法在编译阶段由静态检查来解决的。就像前面提到的 “循环引用制造内存泄漏”一样,编译器无法通过静态检查来完全避免这个问题,需要程序 员 自 己 注 意 。
更多推荐


所有评论(0)