Sender 与 Receiver
核心概念
Sender<T> 和 Receiver<T> 是 mpsc::channel() 返回的一对端点。Sender 负责发送数据,Receiver 负责接收数据。它们之间通过通道连接,数据从 Sender 流向 Receiver。Sender 实现了 Clone,可以复制出多个发送端(多生产者),但 Receiver 不能 Clone(单消费者)。两者都实现了 Send,可以安全地跨线程传递。当所有 Sender 被 drop 时通道关闭,Receiver 的 recv() 返回 Err;反之当 Receiver 被 drop 时,Sender 的 send() 返回 Err。
use std::sync::mpsc::{self, Sender, Receiver};
use std::thread;
fn main() {
// channel() 返回 (Sender<T>, Receiver<T>)
let (tx, rx): (Sender<String>, Receiver<String>) = mpsc::channel();
// Sender 可以跨线程传递
thread::spawn(move || {
tx.send("Hello from thread".to_string()).unwrap();
});
// Receiver 接收数据
let msg = rx.recv().unwrap();
println!("收到: {}", msg);
}Sender 的方法和特性
use std::sync::mpsc;
use std::thread;
use std::time::Duration;
fn main() {
let (tx, rx) = mpsc::channel();
// send():发送数据,返回 Result
tx.send(1).unwrap();
tx.send(2).unwrap();
tx.send(3).unwrap();
// clone():创建新的发送端
let tx2 = tx.clone();
tx2.send(4).unwrap();
// drop 原始 tx,但 tx2 仍在,通道不会关闭
drop(tx);
tx2.send(5).unwrap();
// drop tx2 后通道关闭
drop(tx2);
// 接收所有消息
while let Ok(val) = rx.recv() {
println!("收到: {}", val);
}
println!("通道已关闭");
// send 失败场景:Receiver 已被 drop
let (tx, rx) = mpsc::channel::<i32>();
drop(rx); // 先关闭接收端
match tx.send(42) {
Ok(()) => println!("发送成功"),
Err(e) => println!("发送失败: {} (值: {})", e, e.0),
// SendError 包含了未能发送的值,可以取回
}
}Receiver 的方法和特性
use std::sync::mpsc;
use std::thread;
use std::time::Duration;
fn main() {
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
thread::sleep(Duration::from_millis(100));
tx.send("消息1").unwrap();
thread::sleep(Duration::from_millis(100));
tx.send("消息2").unwrap();
});
// recv():阻塞等待
println!("recv: {:?}", rx.recv());
// try_recv():非阻塞
match rx.try_recv() {
Ok(msg) => println!("try_recv 立即: {}", msg),
Err(mpsc::TryRecvError::Empty) => println!("try_recv: 暂无消息"),
Err(mpsc::TryRecvError::Disconnected) => println!("try_recv: 断开"),
}
// recv_timeout():带超时
match rx.recv_timeout(Duration::from_millis(200)) {
Ok(msg) => println!("recv_timeout: {}", msg),
Err(mpsc::RecvTimeoutError::Timeout) => println!("超时"),
Err(mpsc::RecvTimeoutError::Disconnected) => println!("断开"),
}
// Receiver 作为迭代器
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
for i in 1..=5 {
tx.send(i).unwrap();
}
});
// for 循环遍历,通道关闭时自动结束
let sum: i32 = rx.into_iter().sum();
println!("总和: {}", sum);
// iter() 方法(不消耗 Receiver)
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
for i in 1..=3 {
tx.send(i * 10).unwrap();
}
});
// iter() 返回阻塞迭代器
for val in rx.iter() {
println!("iter: {}", val);
}
}Sender 和 Receiver 的所有权转移
use std::sync::mpsc::{self, Sender, Receiver};
use std::thread;
// Sender 作为函数参数
fn produce(tx: Sender<String>, prefix: &str, count: usize) {
for i in 0..count {
tx.send(format!("{}-{}", prefix, i)).unwrap();
}
// tx 在函数结束时被 drop
}
// Receiver 作为函数参数
fn consume(rx: Receiver<String>) -> Vec<String> {
rx.into_iter().collect()
}
fn main() {
let (tx, rx) = mpsc::channel();
// 传递 Sender 到不同线程
let tx1 = tx.clone();
let tx2 = tx.clone();
thread::spawn(move || produce(tx1, "线程A", 3));
thread::spawn(move || produce(tx2, "线程B", 3));
// 必须 drop 原始 tx,否则通道不会关闭
drop(tx);
// 传递 Receiver 到消费函数
let results = consume(rx);
println!("收到 {} 条消息:", results.len());
for msg in &results {
println!(" {}", msg);
}
}Sender 和 Receiver 的类型推断
use std::sync::mpsc;
use std::thread;
fn main() {
// 类型由发送的数据推断
let (tx, rx) = mpsc::channel();
tx.send(42_i32).unwrap(); // T 被推断为 i32
let val: i32 = rx.recv().unwrap();
println!("i32: {}", val);
// 也可以显式指定类型
let (tx, rx) = mpsc::channel::<String>();
tx.send("hello".to_string()).unwrap();
println!("String: {}", rx.recv().unwrap());
// 发送枚举实现多种消息类型
#[derive(Debug)]
enum Message {
Text(String),
Number(i64),
Quit,
}
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
tx.send(Message::Text("hello".to_string())).unwrap();
tx.send(Message::Number(42)).unwrap();
tx.send(Message::Text("world".to_string())).unwrap();
tx.send(Message::Quit).unwrap();
});
loop {
match rx.recv().unwrap() {
Message::Text(s) => println!("文本: {}", s),
Message::Number(n) => println!("数字: {}", n),
Message::Quit => {
println!("收到退出命令");
break;
}
}
}
}基本示例
用 Sender 和 Receiver 构建一个生产者-消费者模式:
use std::sync::mpsc;
use std::thread;
use std::time::{Duration, Instant};
#[derive(Debug)]
struct WorkItem {
id: usize,
data: String,
}
#[derive(Debug)]
struct WorkResult {
id: usize,
output: String,
process_time_ms: u64,
}
fn main() {
let start = Instant::now();
// 任务通道
let (task_tx, task_rx) = mpsc::channel::<WorkItem>();
// 结果通道
let (result_tx, result_rx) = mpsc::channel::<WorkResult>();
// 生产者:生成任务
let producer = thread::spawn(move || {
let items = vec![
"用户认证", "数据查询", "报告生成",
"缓存更新", "日志分析", "邮件发送",
];
for (i, item) in items.into_iter().enumerate() {
let work = WorkItem {
id: i,
data: item.to_string(),
};
println!("[{:>4}ms] 生产: {:?}", start.elapsed().as_millis(), work);
task_tx.send(work).unwrap();
thread::sleep(Duration::from_millis(30));
}
// task_tx drop → 任务通道关闭
});
// 消费者:处理任务
let consumer = thread::spawn(move || {
for item in task_rx {
let proc_start = Instant::now();
// 模拟处理
let sleep_ms = 50 + (item.id as u64 * 20);
thread::sleep(Duration::from_millis(sleep_ms));
let result = WorkResult {
id: item.id,
output: format!("{}已完成", item.data),
process_time_ms: proc_start.elapsed().as_millis() as u64,
};
println!("[{:>4}ms] 消费: {:?}", start.elapsed().as_millis(), result);
result_tx.send(result).unwrap();
}
// result_tx drop → 结果通道关闭
});
// 收集结果
let collector = thread::spawn(move || {
let mut results = Vec::new();
for result in result_rx {
results.push(result);
}
results
});
// 等待生产者和消费者完成
producer.join().unwrap();
consumer.join().unwrap();
// 收集最终结果
let all_results = collector.join().unwrap();
println!("\n=== 汇总 ===");
println!("总任务: {}个", all_results.len());
let total_time: u64 = all_results.iter().map(|r| r.process_time_ms).sum();
let avg_time = total_time / all_results.len() as u64;
println!("平均处理时间: {}ms", avg_time);
println!("总耗时: {:?}", start.elapsed());
}常见问题
问题一:Sender 和 Receiver 可以在同一个线程中使用吗?
可以。但 recv() 是阻塞的,如果在同一个线程中先 recv 再 send 就会死锁。应该先 send 再 recv,或者用 try_recv。
问题二:为什么 Receiver 不能 clone?
mpsc 的设计是"单消费者"。如果需要多个消费者,可以用 crossbeam crate 的 mpmc 通道,或者手动用 Arc<Mutex<Receiver>> 包装(但不推荐,因为同一时间只有一个线程能接收)。
问题三:SendError 里的值可以取回吗?
可以。SendError<T> 包含了发送失败的值,通过 error.0 可以取回,避免数据丢失。
问题四:通道传递数据有性能开销吗?
通道传递的是数据的所有权(move),不涉及拷贝(除非数据本身是 Copy 类型)。主要开销是内部的锁同步和内存分配。对于大数据,可以传递 Box 或 Arc 来避免大块数据的移动。
适用场景
- 线程间通信:生产者-消费者模式
- 任务分发:主线程发送任务,工作线程处理
- 结果收集:工作线程将结果发回主线程
- 事件驱动:用枚举消息实现命令模式
注意事项
Sender可以clone(多生产者),Receiver不能(单消费者)- 所有
Senderdrop 后通道关闭,recv()返回Err Receiverdrop 后,send()返回ErrSendError包含了发送失败的值,可以取回- 数据类型
T必须实现Send - 用枚举可以在同一个通道中传递多种消息类型
总结
Sender<T> 和 Receiver<T> 是 mpsc 通道的两个端点。Sender 通过 send() 发送数据,可以 clone 支持多个生产者。Receiver 通过 recv()(阻塞)、try_recv()(非阻塞)、recv_timeout()(超时)接收数据,不能 clone(单消费者)。Receiver 实现了 IntoIterator,可以用 for 循环遍历直到通道关闭。所有 Sender 被 drop 时通道关闭。SendError 包含发送失败的值可以取回。通道传递的是数据所有权,用枚举可以实现多种消息类型。