前文中咱们聊了Rust如何管理线程以及如何利用Rust中的锁进行编程。今天咱们继续学习并发编程，web
原子类型
许多编程语言都会提供原子类型，Rust也不例外，在前文中咱们聊了Rust中锁的使用，有了锁，就要当心死锁的问题，Rust虽然声称是安全并发，可是仍然没法帮助咱们解决死锁的问题。原子类型就是编程语言为咱们提供的无锁并发编程的最佳手段。熟悉Java的同窗应该知道，Java的编译器并不能保证代码的执行顺序，编译器会对咱们的代码的执行顺序进行优化，这一操做成为指令重排。而Rust的多线程内存模型不会进行指令重排，它能够保证指令的执行顺序。编程
一般来说原子类型会提供如下操做：安全
Load：从原子类型读取值微信
Store：为一个原子类型写入值多线程
CAS（Compare-And-Swap）：比较并交换并发
Swap：交换异步
Fetch-add（sub/and/or）：表示一系列的原子的加减或逻辑运算编程语言
Ok，这些基础的概念聊完之后，咱们就来看看Rust为咱们提供了哪些原子类型。Rust的原子类型定义在标准库std::sync::atomic中，目前它提供了12种原子类型。编辑器
下面这段代码是Rust演示了如何用原子类型实现一个自旋锁。函数
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::thread;
fn main() {
let spinlock = Arc::new(AtomicUsize::new(1));
let spinlock_clone = spinlock.clone();
let thread = thread::spawn(move|| {
spinlock_clone.store(0, Ordering::SeqCst);
});
while spinlock.load(Ordering::SeqCst) != 0 {}
if let Err(panic) = thread.join() {
println!("Thread had an error: {:?}", panic);
}
}
咱们利用AtomicUsize的store方法将它的值设置为0，而后用load方法获取到它的值，若是不是0，则程序一直空转。在store和load方法中，咱们都用到了一个参数：Ordering::SeqCst，在声明中能看出来它也是属于atomic包。
咱们在文档中发现它是一个枚举。其定义为
pub enum Ordering {
Relaxed,
Release,
Acquire,
AcqRel,
SeqCst,
}
它的做用是将内存顺序的控制权交给开发者，咱们能够本身定义底层的内存排序。下面咱们一块儿来看一下这5种排序分别表明什么意思
Relaxed：表示「没有顺序」，也就是开发者不会干预线程顺序，线程只进行原子操做
Release：对于使用Release的store操做，在它以前全部使用Acquire的load操做都是可见的
Acquire：对于使用Acquire的load操做，在它以前的全部使用Release的store操做也都是可见的
AcqRel：它表明读时使用Acquire顺序的load操做，写时使用Release顺序的store操做
SeqCst：使用了SeqCst的原子操做都必须先存储，再加载。
通常状况下建议使用SeqCst，而不推荐使用Relaxed。
线程间通讯
Go语言文档中有这样一句话：不要使用共享内存来通讯，应该使用通讯实现共享内存。
Rust标准库选择了CSP并发模型，也就是依赖channel来进行线程间的通讯。它的定义是在标准库std::sync::mpsc中，里面定义了三种类型的CSP进程：
Sender：发送异步消息
SyncSender：发送同步消息
Receiver：用于接收消息
咱们经过一个栗子来看一下channel是如何建立并收发消息的。
use std::thread;
use std::sync::mpsc;
fn main() {
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
let val = String::from("hi");
tx.send(val).unwrap();
});
let received = rx.recv().unwrap();
println!("Got: {}", received);
}
首先，咱们先是使用了channel()函数来建立一个channel，它会返回一个（Sender, Receiver）元组。它的缓冲区是无界的。此外，咱们还可使用sync_channel()来建立channel，它返回的则是（SyncSender, Receiver）元组，这样的channel发送消息是同步的，而且能够设置缓冲区大小。
接着，在子线程中，咱们定义了一个字符串变量，并使用send()函数向channel中发送消息。这里send返回的是一个Result类型，因此使用unwrap来传播错误。
在main函数最后，咱们又用recv()函数来接收消息。
这里须要注意的是，send()函数会转移全部权，因此，若是你在发送消息以后再使用val变量时，程序就会报错。
如今咱们已经掌握了使用Channel进行线程间通讯的方法了，这里还有一段代码，感兴趣的同窗能够本身执行一下这段代码看是否可以顺利执行。若是不能，应该怎么修改这段代码呢？
use std::thread;
use std::sync::mpsc;
fn main() {
let (tx, rx) = mpsc::channel();
for i in 0..5 {
let tx = tx.clone();
thread::spawn(move || {
tx.send(i).unwrap();
});
}
for rx in rx.iter() {
println!("{:?}", j);
}
}
线程池
在实际工做中，若是每次都要建立新的线程，每次建立、销毁线程的开销就会变得很是可观，甚至会成为系统性能的瓶颈。对于这种问题，咱们一般使用线程池来解决。
Rust的标准库中没有现成的线程池给咱们使用，不过仍是有一些第三方库来支持的。这里我使用的是threadpool（https://crates.io/crates/threadpool）。
首先须要在Cargo.toml中增长依赖threadpool = "1.7.1"。而后就可使用use threadpool::ThreadPool;将ThreadPool引入咱们的程序中了。
use threadpool::ThreadPool;
use std::sync::mpsc::channel;
fn main() {
let n_workers = 4;
let n_jobs = 8;
let pool = ThreadPool::new(n_workers);
let (tx, rx) = channel();
for _ in 0..n_jobs {
let tx = tx.clone();
pool.execute(move|| {
tx.send(1).expect("channel will be there waiting for the pool");
});
}
assert_eq!(rx.iter().take(n_jobs).fold(0, |a, b| a + b), 8);
}
这里咱们使用ThreadPool::new()来建立一个线程池，初始化4个工做线程。使用时用execute()方法就能够拿出一个线程来进行具体的工做。
总结
今天咱们介绍了Rust并发编程的三种特性：原子类型、线程间通讯和线程池的使用。
原子类型是咱们进行无锁并发的重要手段，线程间通讯和线程池也都是工做中所必须使用的。固然并发编程的知识远不止于此，你们有兴趣的能够自行学习也能够与我交流讨论。
本文分享自微信公众号 - 代码洁癖患者（Jackeyzhe2018）。
若有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一块儿分享。