同步通道 sync_channel
核心概念
mpsc::sync_channel(bound) 创建一个有界的同步通道,缓冲区最多容纳 bound 条消息。当缓冲区满时,send() 会阻塞发送线程,直到接收方取走一条消息腾出空间。这和无界通道(mpsc::channel())的关键区别在于:无界通道的 send() 永远不会阻塞(缓冲区会无限增长),而同步通道通过阻塞发送方来实现背压(backpressure),防止生产者速度远超消费者导致内存无限增长。sync_channel(0) 是特殊情况——缓冲区为零,每次 send 都必须等到对方 recv 才能完成,实现了严格的"握手"同步。
use std::sync::mpsc;
use std::thread;
use std::time::Duration;
fn main() {
// 创建容量为 2 的同步通道
let (tx, rx) = mpsc::sync_channel(2);
thread::spawn(move || {
for i in 1..=5 {
println!("发送 {}...", i);
tx.send(i).unwrap(); // 缓冲区满时会阻塞
println!("发送 {} 完成", i);
}
});
// 故意慢速接收,观察发送方的阻塞
for _ in 0..5 {
thread::sleep(Duration::from_millis(300));
let val = rx.recv().unwrap();
println!(" 接收: {}", val);
}
}sync_channel 与 channel 的对比
use std::sync::mpsc;
use std::thread;
use std::time::{Duration, Instant};
fn main() {
// === 无界通道:send 永不阻塞 ===
let (tx, rx) = mpsc::channel();
let start = Instant::now();
let producer = thread::spawn(move || {
for i in 0..5 {
tx.send(i).unwrap();
println!("[{:>4}ms] 无界 send {}", start.elapsed().as_millis(), i);
}
// 所有 send 立即完成
});
thread::sleep(Duration::from_millis(500));
producer.join().unwrap();
while let Ok(v) = rx.try_recv() {
println!(" 无界 recv: {}", v);
}
// === 同步通道(容量1):send 可能阻塞 ===
let (tx, rx) = mpsc::sync_channel(1);
let start = Instant::now();
let producer = thread::spawn(move || {
for i in 0..5 {
println!("[{:>4}ms] 同步 send {}...", start.elapsed().as_millis(), i);
tx.send(i).unwrap(); // 缓冲区满时阻塞
println!("[{:>4}ms] 同步 send {} 完成", start.elapsed().as_millis(), i);
}
});
// 慢速接收
for _ in 0..5 {
thread::sleep(Duration::from_millis(200));
let val = rx.recv().unwrap();
println!("[{:>4}ms] 同步 recv: {}", start.elapsed().as_millis(), val);
}
producer.join().unwrap();
}| 特性 | channel()(无界) | sync_channel(n)(有界) |
|---|---|---|
| 缓冲区 | 无限增长 | 最多 n 条 |
send() 阻塞 | 永不阻塞 | 缓冲区满时阻塞 |
| 内存控制 | 无(可能 OOM) | 有背压限制 |
| 发送端类型 | Sender<T> | SyncSender<T> |
try_send() | 无 | 有(非阻塞) |
| 适用场景 | 突发流量、低延迟 | 流量控制、稳定内存 |
零容量通道(Rendezvous Channel)
use std::sync::mpsc;
use std::thread;
use std::time::{Duration, Instant};
fn main() {
// sync_channel(0):缓冲区为零
// send 必须等到 recv 准备好才能完成
let (tx, rx) = mpsc::sync_channel(0);
let start = Instant::now();
thread::spawn(move || {
for i in 1..=3 {
println!("[{:>4}ms] send {}...",
start.elapsed().as_millis(), i);
tx.send(i).unwrap();
// send 在 recv 取走数据后才返回
println!("[{:>4}ms] send {} 完成(对方已接收)",
start.elapsed().as_millis(), i);
}
});
for _ in 0..3 {
thread::sleep(Duration::from_millis(300));
println!("[{:>4}ms] 准备接收...", start.elapsed().as_millis());
let val = rx.recv().unwrap();
println!("[{:>4}ms] recv: {}", start.elapsed().as_millis(), val);
}
// 零容量通道实现了严格的同步握手
// 发送方和接收方在每次传递时都"会合"
}try_send 非阻塞发送
use std::sync::mpsc;
use std::thread;
use std::time::Duration;
fn main() {
let (tx, rx) = mpsc::sync_channel(2);
// 先填满缓冲区
tx.send(1).unwrap();
tx.send(2).unwrap();
// try_send:缓冲区满时立即返回错误,不阻塞
match tx.try_send(3) {
Ok(()) => println!("try_send 成功"),
Err(mpsc::TrySendError::Full(val)) => {
println!("缓冲区已满,值 {} 未发送", val);
// 可以取回未发送的值
}
Err(mpsc::TrySendError::Disconnected(val)) => {
println!("通道已关闭,值 {} 未发送", val);
}
}
// 接收一个后再 try_send
let _ = rx.recv().unwrap();
match tx.try_send(3) {
Ok(()) => println!("try_send 成功"),
Err(e) => println!("try_send 失败: {:?}", e),
}
// 接收所有
drop(tx);
for val in rx {
println!("收到: {}", val);
}
// 实际场景:用 try_send 实现非阻塞日志
let (log_tx, log_rx) = mpsc::sync_channel(100);
// 日志写入线程
let writer = thread::spawn(move || {
for msg in log_rx {
println!("[日志] {}", msg);
}
});
// 业务代码中非阻塞写入日志
for i in 0..5 {
match log_tx.try_send(format!("事件 {}", i)) {
Ok(()) => {} // 成功
Err(mpsc::TrySendError::Full(_)) => {
// 日志缓冲区满,丢弃这条日志
eprintln!("日志缓冲区满,丢弃");
}
Err(_) => break,
}
}
drop(log_tx);
writer.join().unwrap();
}基本示例
用同步通道实现带背压的流水线:
use std::sync::mpsc;
use std::thread;
use std::time::{Duration, Instant};
fn main() {
let start = Instant::now();
// 三阶段流水线,每阶段的同步通道限制缓冲
let (raw_tx, raw_rx) = mpsc::sync_channel::<String>(2);
let (processed_tx, processed_rx) = mpsc::sync_channel::<String>(2);
let (final_tx, final_rx) = mpsc::sync_channel::<String>(2);
// 阶段1:数据采集(快速)
let s = start.clone();
let collector = thread::spawn(move || {
let items = vec![
"原始数据A", "原始数据B", "原始数据C",
"原始数据D", "原始数据E", "原始数据F",
];
for item in items {
println!("[{:>4}ms] 采集: {}", s.elapsed().as_millis(), item);
raw_tx.send(item.to_string()).unwrap();
thread::sleep(Duration::from_millis(50));
}
});
// 阶段2:数据处理(中速)
let s = start.clone();
let processor = thread::spawn(move || {
for raw in raw_rx {
thread::sleep(Duration::from_millis(150)); // 处理耗时
let result = format!("[已处理] {}", raw);
println!("[{:>4}ms] 处理: {}", s.elapsed().as_millis(), result);
processed_tx.send(result).unwrap();
}
});
// 阶段3:数据存储(慢速)
let s = start.clone();
let writer = thread::spawn(move || {
for data in processed_rx {
thread::sleep(Duration::from_millis(200)); // 写入耗时
let saved = format!("[已保存] {}", data);
println!("[{:>4}ms] 存储: {}", s.elapsed().as_millis(), saved);
final_tx.send(saved).unwrap();
}
});
// 收集最终结果
let results: Vec<String> = final_rx.into_iter().collect();
collector.join().unwrap();
processor.join().unwrap();
writer.join().unwrap();
println!("\n=== 最终结果 ({} 条) ===", results.len());
for r in &results {
println!(" {}", r);
}
println!("总耗时: {:?}", start.elapsed());
// 对比:如果不限制缓冲区
// 采集线程会瞬间把所有数据塞进通道
// 内存使用不可控
// 同步通道让快的阶段等慢的阶段,内存使用稳定
// === 容量选择的影响 ===
println!("\n=== 容量测试 ===");
for cap in [0, 1, 5, 100] {
let (tx, rx) = mpsc::sync_channel(cap);
let s = Instant::now();
let producer = thread::spawn(move || {
for i in 0..10 {
tx.send(i).unwrap();
}
});
// 短暂延迟后接收
thread::sleep(Duration::from_millis(50));
let received: Vec<i32> = rx.into_iter().collect();
producer.join().unwrap();
println!(" 容量={}: 耗时={:?}, 收到={:?}",
cap, s.elapsed(), received.len());
}
}常见问题
问题一:sync_channel 的容量应该设多大?
取决于生产和消费的速度差。容量太小会频繁阻塞生产者,容量太大失去背压的意义。一般从小容量开始(如 10-100),根据性能测试调整。容量为 0 实现严格同步。
问题二:sync_channel 和 channel 该用哪个?
如果生产者速度可能远超消费者,用 sync_channel 防止内存无限增长。如果生产者是突发性的、消费者能及时消费,用 channel 避免不必要的阻塞。
问题三:SyncSender 和 Sender 有什么区别?
SyncSender 是 sync_channel 返回的发送端,多了 try_send() 方法。Sender 是 channel 返回的发送端,没有 try_send(因为 send 永不阻塞,不需要非阻塞版本)。两者都可以 clone。
问题四:sync_channel 的 send 阻塞时线程在做什么?
线程处于内核等待状态,不消耗 CPU。当接收方取走消息后,发送方被唤醒继续执行。
适用场景
- 背压控制:防止快速生产者压垮慢速消费者
- 内存限制:限制通道中积压的消息数量
- 流水线:多阶段处理中控制各阶段的速度匹配
- 严格同步:
sync_channel(0)实现握手式同步
注意事项
sync_channel(n)的send在缓冲区满时阻塞sync_channel(0)的send总是阻塞直到对方 recv- 返回的是
SyncSender(不是Sender),多了try_send try_send缓冲区满时返回TrySendError::Full(value)SyncSender也可以clone实现多生产者- 容量过小会降低吞吐,容量过大失去背压作用
总结
mpsc::sync_channel(bound) 创建有界同步通道,缓冲区最多 bound 条消息。缓冲区满时 send() 阻塞发送方,实现背压控制。sync_channel(0) 是零缓冲,每次 send 必须等 recv 才能完成(握手同步)。返回的发送端是 SyncSender,额外提供 try_send() 非阻塞发送(缓冲满时返回 Full(value))。同步通道适合生产速度可能远超消费速度的场景,通过阻塞来防止内存无限增长。无界通道 channel() 的 send 永不阻塞但缓冲区可能无限增长。容量的选择需要在吞吐量和内存使用之间权衡。