Linux 下 Rust 并发编程实战技巧
一 模型选型与适用场景
| 模型 | 适用场景 | 关键原语/库 | 注意点 |
|---|---|---|---|
| 多线程 | CPU 密集 | std::thread、Arc、Mutex/RwLock、Atomic | 线程过多增加调度开销；锁粒度要小 |
| 异步 | I/O 密集 | Tokio（async/await、Semaphore、Barrier、Notify） | 禁止在 async 中阻塞；控制并发度 |
| 数据并行 | 计算并行 | Rayon | 自动负载均衡，缓存友好 |
| 以上要点与示例在 Linux 环境下均适用，Tokio 为生产级异步运行时，Rayon 提供高层并行抽象。 |
二 同步与共享内存的正确姿势
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;
use std::thread;
const SHARD: usize = 64;
#[repr(align(64))]
struct AlignedCounter(AtomicU64);
struct ShardedCounter {
shards: Vec<AlignedCounter>,
}
impl ShardedCounter {
fn new() -> Self {
Self { shards: (0..SHARD).map(|_| AlignedCounter(AtomicU64::new(0))).collect() }
}
fn inc(&self) {
let idx = (thread::current().id().as_u64().get() as usize) % SHARD;
self.shards[idx].0.fetch_add(1, Ordering::Relaxed);
}
fn total(&self) -> u64 {
self.shards.iter().map(|s| s.0.load(Ordering::Relaxed)).sum()
}
}
fn main() {
let c = Arc::new(ShardedCounter::new());
let mut hs = vec![];
for _ in 0..8 {
let c = Arc::clone(&c);
hs.push(thread::spawn(move || {
for _ in 0..100_000 { c.inc(); }
}));
}
for h in hs { h.join().unwrap(); }
println!("total = {}", c.total());
}
三 异步并发与任务调度要点
use tokio::sync::Semaphore;
use tokio::sync::mpsc;
use tokio::time::{sleep, Duration};
#[tokio::main(flavor = "multi_thread", worker_threads = 8)]
async fn main() {
let sem = Arc::new(Semaphore::new(10)); // 最多 10 并发
let (tx, mut rx) = mpsc::channel(100); // 有界通道
// 生产者
let p = tokio::spawn({
let sem = sem.clone();
let tx = tx.clone();
async move {
for i in 0..100 {
let permit = sem.clone().acquire_owned().await.unwrap();
tx.send(i).await.unwrap();
tokio::spawn(async move { drop(permit); });
sleep(Duration::from_millis(5)).await;
}
}
});
// 消费者
let c = tokio::spawn(async move {
while let Some(i) = rx.recv().await {
// 模拟处理
sleep(Duration::from_millis(20)).await;
println!("processed {}", i);
}
});
p.await.unwrap();
c.await.unwrap();
}
四 性能优化与常见陷阱
use std::thread;
fn main() {
let mut handles = Vec::with_capacity(8);
for i in 0..8 {
handles.push(thread::spawn(move || {
let mut local = Vec::with_capacity(100_000);
for j in 0..100_000 { local.push(i * j); }
local
}));
}
let result: Vec<_> = handles.into_iter()
.flat_map(|h| h.join().unwrap())
.collect();
println!("len = {}", result.len());
}
五 调试与测试工具链
