多生产者克隆 Sender ​

核心概念 ​

mpsc 通道的"mp"代表 Multi-Producer(多生产者),通过 clone() 方法可以从一个 Sender 复制出多个发送端,所有克隆的 Sender 共享同一个通道,向同一个 Receiver 发送数据。每个 Sender 克隆体可以独立发送到不同的线程中使用。通道内部维护着一个引用计数,只有当所有 Sender(包括原始的和所有克隆的)都被 drop 后,通道才会关闭。这是 Rust 中实现"多个线程向同一个接收者发送消息"的标准模式。

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 的正确模式 ​

rust
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 的问题 ​

rust
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);
}

多生产者的消息顺序 ​

rust
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);
    }
}

多生产者带标识 ​

rust
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);
    }
}

基本示例 ​

用多生产者模式实现并行网页抓取模拟:

rust
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 并发发送是线程安全的,但消息到达顺序不确定。如果需要有序,可以在消息中包含序号。多生产者模式广泛用于多线程结果汇报、事件聚合、日志收集等场景。