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。

rust
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 的方法和特性 ​

rust
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 的方法和特性 ​

rust
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 的所有权转移 ​

rust
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 的类型推断 ​

rust
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 构建一个生产者-消费者模式:

rust
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 不能(单消费者)
  • 所有 Sender drop 后通道关闭,recv() 返回 Err
  • Receiver drop 后,send() 返回 Err
  • SendError 包含了发送失败的值,可以取回
  • 数据类型 T 必须实现 Send
  • 用枚举可以在同一个通道中传递多种消息类型

总结 ​

Sender<T> 和 Receiver<T> 是 mpsc 通道的两个端点。Sender 通过 send() 发送数据,可以 clone 支持多个生产者。Receiver 通过 recv()(阻塞)、try_recv()(非阻塞)、recv_timeout()(超时)接收数据,不能 clone(单消费者)。Receiver 实现了 IntoIterator,可以用 for 循环遍历直到通道关闭。所有 Sender 被 drop 时通道关闭。SendError 包含发送失败的值可以取回。通道传递的是数据所有权,用枚举可以实现多种消息类型。