多生产者克隆 Sender
核心概念
mpsc 通道的"mp"代表 Multi-Producer(多生产者),通过 clone() 方法可以从一个 Sender 复制出多个发送端,所有克隆的 Sender 共享同一个通道,向同一个 Receiver 发送数据。每个 Sender 克隆体可以独立发送到不同的线程中使用。通道内部维护着一个引用计数,只有当所有 Sender(包括原始的和所有克隆的)都被 drop 后,通道才会关闭。这是 Rust 中实现"多个线程向同一个接收者发送消息"的标准模式。
use std::sync::mpsc;
use std::thread;
fn main() {
let (tx, rx) = mpsc::channel();
// 克隆出多个 Sender
let tx1 = tx.clone();
let tx2 = tx.clone();
let tx3 = tx.clone();
// 必须 drop 原始 tx,否则通道不会关闭
drop(tx);
// 每个线程用自己的 Sender
thread::spawn(move || {
tx1.send("来自线程1").unwrap();
});
thread::spawn(move || {
tx2.send("来自线程2").unwrap();
});
thread::spawn(move || {
tx3.send("来自线程3").unwrap();
});
// 一个 Receiver 接收所有消息
for msg in rx {
println!("收到: {}", msg);
}
}克隆 Sender 的正确模式
use std::sync::mpsc;
use std::thread;
fn main() {
let (tx, rx) = mpsc::channel();
let mut handles = Vec::new();
for i in 0..5 {
// 每次循环 clone 一个新的 Sender
let tx_clone = tx.clone();
handles.push(thread::spawn(move || {
// 每个线程拥有自己的 tx_clone
for j in 0..3 {
tx_clone.send(format!("线程{}-消息{}", i, j)).unwrap();
}
// tx_clone 在线程结束时 drop
}));
}
// 关键:drop 原始的 tx
// 如果不 drop,即使所有线程结束,通道也不会关闭
// 因为原始 tx 还活着
drop(tx);
// 等待所有线程完成
for h in handles {
h.join().unwrap();
}
// 收集所有消息
let messages: Vec<String> = rx.into_iter().collect();
println!("共收到 {} 条消息", messages.len());
for msg in &messages {
println!(" {}", msg);
}
}忘记 drop 原始 Sender 的问题
use std::sync::mpsc;
use std::thread;
use std::time::Duration;
fn main() {
let (tx, rx) = mpsc::channel();
let tx_clone = tx.clone();
thread::spawn(move || {
tx_clone.send("消息").unwrap();
});
// 如果不 drop 原始 tx,下面的 for 循环会永远阻塞
// 因为通道永远不会关闭(原始 tx 还在)
// 正确做法:drop 原始 tx
drop(tx);
// 现在 for 循环可以正常结束
for msg in rx {
println!("收到: {}", msg);
}
println!("正常结束");
// 另一种模式:在代码块中限定 tx 的作用域
let (tx, rx) = mpsc::channel();
{
for i in 0..3 {
let tx = tx.clone();
thread::spawn(move || {
tx.send(i).unwrap();
});
}
} // 这里 tx 的克隆体随线程 move 走了
drop(tx); // 仍然需要 drop 原始的
let results: Vec<i32> = rx.into_iter().collect();
println!("结果: {:?}", results);
}多生产者的消息顺序
use std::sync::mpsc;
use std::thread;
use std::time::Duration;
fn main() {
let (tx, rx) = mpsc::channel();
// 多个生产者发送的消息到达顺序不确定
for i in 0..5 {
let tx = tx.clone();
thread::spawn(move || {
// 不同线程可能以不同速度运行
thread::sleep(Duration::from_millis(10 * ((5 - i) as u64)));
tx.send(format!("线程{}", i)).unwrap();
});
}
drop(tx);
println!("消息到达顺序(可能每次不同):");
for (idx, msg) in rx.into_iter().enumerate() {
println!(" 第{}条: {}", idx + 1, msg);
}
// 如果需要有序,可以在消息中包含序号
let (tx, rx) = mpsc::channel();
for i in 0..5 {
let tx = tx.clone();
thread::spawn(move || {
thread::sleep(Duration::from_millis(10 * ((5 - i) as u64)));
tx.send((i, format!("数据{}", i))).unwrap();
});
}
drop(tx);
let mut messages: Vec<(usize, String)> = rx.into_iter().collect();
messages.sort_by_key(|(id, _)| *id); // 按序号排序
println!("\n按序号排序后:");
for (id, msg) in &messages {
println!(" [{}] {}", id, msg);
}
}多生产者带标识
use std::sync::mpsc;
use std::thread;
use std::time::Duration;
#[derive(Debug)]
struct TaggedMessage {
source: String,
content: String,
timestamp_ms: u128,
}
fn main() {
let start = std::time::Instant::now();
let (tx, rx) = mpsc::channel();
let sources = vec![
("传感器A", vec![22.5, 23.0, 22.8]),
("传感器B", vec![18.1, 18.3]),
("传感器C", vec![30.0, 29.5, 30.2, 29.8]),
];
for (name, readings) in sources {
let tx = tx.clone();
let start = start.clone();
let name = name.to_string();
thread::spawn(move || {
for value in readings {
let msg = TaggedMessage {
source: name.clone(),
content: format!("{:.1}°C", value),
timestamp_ms: start.elapsed().as_millis(),
};
tx.send(msg).unwrap();
thread::sleep(Duration::from_millis(50));
}
});
}
drop(tx);
// 汇总接收
println!("=== 传感器数据 ===");
let mut by_source: std::collections::HashMap<String, Vec<String>> =
std::collections::HashMap::new();
for msg in rx {
println!(" [{:>4}ms] {}: {}",
msg.timestamp_ms, msg.source, msg.content);
by_source.entry(msg.source)
.or_insert_with(Vec::new)
.push(msg.content);
}
println!("\n=== 按来源汇总 ===");
for (source, readings) in &by_source {
println!(" {}: {} 个读数 {:?}", source, readings.len(), readings);
}
}基本示例
用多生产者模式实现并行网页抓取模拟:
use std::sync::mpsc;
use std::thread;
use std::time::{Duration, Instant};
#[derive(Debug)]
struct FetchResult {
url: String,
status: u16,
body_size: usize,
elapsed_ms: u64,
}
fn simulate_fetch(url: &str) -> FetchResult {
// 模拟不同 URL 的不同延迟
let delay = match url {
u if u.contains("fast") => 50,
u if u.contains("slow") => 300,
u if u.contains("error") => 100,
_ => 150,
};
thread::sleep(Duration::from_millis(delay));
let status = if url.contains("error") { 500 } else { 200 };
let body_size = if status == 200 { 1024 + delay as usize * 10 } else { 0 };
FetchResult {
url: url.to_string(),
status,
body_size,
elapsed_ms: delay,
}
}
fn main() {
let start = Instant::now();
let urls = vec![
"https://example.com/fast/page1",
"https://example.com/api/data",
"https://example.com/slow/report",
"https://example.com/fast/page2",
"https://example.com/error/broken",
"https://example.com/api/users",
"https://example.com/slow/analytics",
"https://example.com/fast/page3",
];
let (tx, rx) = mpsc::channel();
let total_urls = urls.len();
// 每个 URL 在独立线程中抓取
for url in urls {
let tx = tx.clone();
let url = url.to_string();
thread::spawn(move || {
let result = simulate_fetch(&url);
tx.send(result).unwrap();
});
}
drop(tx); // 释放原始 Sender
// 收集所有结果
let mut results = Vec::new();
let mut success = 0;
let mut failure = 0;
println!("=== 抓取结果 ===");
for result in rx {
let status_text = if result.status == 200 { "成功" } else { "失败" };
println!(" [{}] {} - {} ({} 字节, {}ms)",
status_text, result.url, result.status,
result.body_size, result.elapsed_ms);
if result.status == 200 { success += 1; } else { failure += 1; }
results.push(result);
}
let total_time = start.elapsed();
println!("\n=== 统计 ===");
println!("总URL: {}", total_urls);
println!("成功: {}, 失败: {}", success, failure);
let total_bytes: usize = results.iter().map(|r| r.body_size).sum();
println!("总数据量: {} 字节", total_bytes);
let avg_time: f64 = results.iter()
.map(|r| r.elapsed_ms as f64)
.sum::<f64>() / results.len() as f64;
println!("平均响应时间: {:.0}ms", avg_time);
println!("总耗时: {:?}(并行执行)", total_time);
let serial_time: u64 = results.iter().map(|r| r.elapsed_ms).sum();
println!("串行预估: {}ms", serial_time);
println!("加速比: {:.1}x", serial_time as f64 / total_time.as_millis() as f64);
}常见问题
问题一:clone 一个 Sender 的成本是多少?
很低。Sender::clone 只是增加通道内部的引用计数(类似 Arc 的 clone),不复制缓冲区数据。
问题二:忘记 drop 原始 Sender 会怎样?
如果用 for msg in rx 遍历通道,会永远阻塞,因为通道不会关闭(还有一个 Sender 活着)。这是 Rust 并发编程中一个常见的陷阱。
问题三:多个 Sender 同时 send 线程安全吗?
安全。Sender 实现了 Send,通道内部有同步机制保证并发 send 的安全。但消息到达 Receiver 的顺序不确定。
问题四:可以有多少个 Sender?
理论上没有限制(取决于内存)。每个 clone 只增加一个引用计数。实际使用中几十到几百个是常见的。
适用场景
- 多线程汇报:多个工作线程向一个收集线程发送结果
- 事件聚合:多个事件源汇聚到一个处理器
- 日志收集:多个模块的日志汇总到一个写入线程
- 并行抓取:多个线程并行获取数据并汇总
注意事项
- 使用 clone 后必须 drop 原始 Sender,否则通道不关闭
- 多个 Sender 发送的消息到达顺序不确定
Sender::clone开销很小(只增加引用计数)- 所有 Sender 都 drop 后通道才关闭
- 在循环中 clone 时,每次迭代 move 进线程
- 如果需要有序消息,在消息中加入序号字段
总结
Sender 通过 clone() 实现多生产者模式,多个线程可以向同一个 Receiver 发送消息。clone 的成本很低,只增加引用计数。所有 Sender(包括原始的和克隆的)都 drop 后通道才关闭,忘记 drop 原始 Sender 会导致 for 循环永远阻塞。多个 Sender 并发发送是线程安全的,但消息到达顺序不确定。如果需要有序,可以在消息中包含序号。多生产者模式广泛用于多线程结果汇报、事件聚合、日志收集等场景。