通道所有权转移 ​

核心概念 ​

通道传递数据时执行的是所有权转移(move),而不是拷贝或共享。send(value) 之后,发送方不再拥有 value,接收方通过 recv() 获得完整的所有权。这是 Rust 所有权系统在并发场景中的自然延伸——通过转移所有权来保证同一时刻只有一个线程拥有数据,从根本上避免了数据竞争。对于 Copy 类型(如 i32),send 实际上是复制了一份;对于非 Copy 类型(如 String、Vec),send 后原变量就不能再使用了。

rust
use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let data = String::from("这是一段数据");
        println!("发送前: {}", data);

        // send 转移了 data 的所有权
        tx.send(data).unwrap();

        // data 已经被移走,不能再使用
        // println!("{}", data);  // 编译错误:value used after move
    });

    // 接收方获得所有权
    let received = rx.recv().unwrap();
    println!("接收到: {}", received);
    // received 现在完全属于主线程
}

所有权转移的意义 ​

rust
use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let mut data = vec![1, 2, 3, 4, 5];

        // 发送前可以修改
        data.push(6);
        println!("发送方: {:?}", data);

        // 发送后所有权转移,发送方不能再修改
        tx.send(data).unwrap();

        // 下面的代码无法编译
        // data.push(7);  // 编译错误
    });

    // 接收方拥有完整的所有权,可以自由修改
    let mut received = rx.recv().unwrap();
    received.push(100);
    println!("接收方修改后: {:?}", received);

    // 不存在两个线程同时修改同一个 Vec 的可能
    // 所有权转移从编译期就保证了这一点
}

Copy 类型与非 Copy 类型的区别 ​

rust
use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        // Copy 类型:send 之后仍可使用(因为是复制)
        let number = 42;
        tx.send(number).unwrap();
        println!("发送后 number 仍可用: {}", number);

        let flag = true;
        tx.send(if flag { 1 } else { 0 }).unwrap();
        println!("发送后 flag 仍可用: {}", flag);
    });

    println!("收到: {}", rx.recv().unwrap());
    println!("收到: {}", rx.recv().unwrap());

    // 非 Copy 类型:send 之后不可使用
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let text = String::from("hello");
        tx.send(text).unwrap();
        // println!("{}", text);  // 编译错误:已移走

        let list = vec![1, 2, 3];
        tx.send(format!("{:?}", list)).unwrap();
        // list 还在,因为 format! 只借用了 list
        println!("list 仍可用: {:?}", list);
    });

    println!("收到: {}", rx.recv().unwrap());
    println!("收到: {}", rx.recv().unwrap());
}
数据类型send 行为发送后原变量示例
Copy 类型复制值仍可使用i32, f64, bool, char
非 Copy 类型转移所有权不可使用String, Vec, HashMap
引用通常不允许N/A&T 需要 'static
Arc<T>clone 后发送clone 仍可用共享只读数据

发送大型数据的策略 ​

rust
use std::sync::mpsc;
use std::thread;
use std::sync::Arc;

fn main() {
    // === 直接发送(移动所有权)===
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let big_data = vec![0u8; 1024 * 1024];  // 1MB 数据
        // 直接 send 移动所有权,不复制数据
        // 只是将指针/长度/容量转移给接收方
        tx.send(big_data).unwrap();
    });

    let data = rx.recv().unwrap();
    println!("收到 {} 字节", data.len());

    // === 用 Box 发送堆上的数据 ===
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let boxed = Box::new([0u8; 1024]);
        tx.send(boxed).unwrap();
    });

    let data = rx.recv().unwrap();
    println!("Box 数据: {} 字节", data.len());

    // === 用 Arc 共享大数据(只读)===
    let (tx, rx) = mpsc::channel();
    let shared_data = Arc::new(vec![0u8; 1024 * 1024]);

    for i in 0..3 {
        let tx = tx.clone();
        let data = Arc::clone(&shared_data);
        thread::spawn(move || {
            // 发送 Arc 的 clone,不复制底层数据
            tx.send((i, data.len())).unwrap();
        });
    }
    drop(tx);

    for msg in rx {
        println!("线程{}: 数据大小 {}", msg.0, msg.1);
    }
}

通道中所有权转移的连锁传递 ​

rust
use std::sync::mpsc;
use std::thread;

fn main() {
    // 数据在多个线程间传递:A → B → C
    let (tx_ab, rx_ab) = mpsc::channel::<Vec<i32>>();
    let (tx_bc, rx_bc) = mpsc::channel::<Vec<i32>>();

    // 线程 A:创建数据并发送给 B
    thread::spawn(move || {
        let data = vec![1, 2, 3, 4, 5];
        println!("A 创建: {:?}", data);
        tx_ab.send(data).unwrap();
        // data 的所有权转移给了通道
    });

    // 线程 B:从 A 接收,处理后发送给 C
    thread::spawn(move || {
        let mut data = rx_ab.recv().unwrap();
        // 现在 B 拥有 data
        println!("B 收到: {:?}", data);

        // B 可以修改
        data.iter_mut().for_each(|x| *x *= 10);
        println!("B 处理后: {:?}", data);

        tx_bc.send(data).unwrap();
        // data 的所有权转移给了通道,B 不再拥有
    });

    // 主线程 C:从 B 接收最终结果
    let result = rx_bc.recv().unwrap();
    println!("C 最终收到: {:?}", result);
    // 数据经历了 A → 通道 → B → 通道 → C 的所有权转移
}

基本示例 ​

用通道所有权转移实现一个安全的工作窃取模式:

rust
use std::sync::mpsc;
use std::thread;
use std::time::{Duration, Instant};

#[derive(Debug)]
struct Task {
    id: usize,
    payload: String,
    priority: u8,
}

#[derive(Debug)]
struct TaskResult {
    task_id: usize,
    worker_id: usize,
    output: String,
}

fn main() {
    let start = Instant::now();

    // 创建任务
    let tasks = vec![
        Task { id: 1, payload: "用户数据分析".to_string(), priority: 3 },
        Task { id: 2, payload: "生成月度报告".to_string(), priority: 2 },
        Task { id: 3, payload: "清理过期缓存".to_string(), priority: 1 },
        Task { id: 4, payload: "发送通知邮件".to_string(), priority: 2 },
        Task { id: 5, payload: "数据库备份".to_string(), priority: 3 },
        Task { id: 6, payload: "日志归档".to_string(), priority: 1 },
    ];

    // 任务分发通道
    let (task_tx, task_rx) = mpsc::channel::<Task>();
    // 结果收集通道
    let (result_tx, result_rx) = mpsc::channel::<TaskResult>();

    // 将 Receiver 包装在 Arc<Mutex> 中让多个 worker 共享
    let task_rx = std::sync::Arc::new(std::sync::Mutex::new(task_rx));

    // 启动 3 个 worker
    let num_workers = 3;
    let mut worker_handles = Vec::new();

    for worker_id in 0..num_workers {
        let task_rx = std::sync::Arc::clone(&task_rx);
        let result_tx = result_tx.clone();

        worker_handles.push(thread::spawn(move || {
            loop {
                // 尝试从共享的 Receiver 获取任务
                let task = {
                    let rx = task_rx.lock().unwrap();
                    rx.recv()
                };

                match task {
                    Ok(task) => {
                        // task 的所有权现在属于这个 worker
                        let sleep_ms = 50 * task.priority as u64;
                        thread::sleep(Duration::from_millis(sleep_ms));

                        let result = TaskResult {
                            task_id: task.id,
                            worker_id,
                            output: format!("完成: {} (优先级{})", task.payload, task.priority),
                        };

                        // result 的所有权转移到通道
                        result_tx.send(result).unwrap();
                    }
                    Err(_) => {
                        // 通道关闭,没有更多任务
                        println!("[{:>4}ms] Worker {} 退出",
                            start.elapsed().as_millis(), worker_id);
                        break;
                    }
                }
            }
        }));
    }

    // drop 多余的 result_tx(worker 的 clone 会在 worker 结束时 drop)
    drop(result_tx);

    // 分发任务(所有权从 tasks vec 转移到通道)
    for task in tasks {
        println!("[{:>4}ms] 分发任务 {}: {}",
            start.elapsed().as_millis(), task.id, task.payload);
        task_tx.send(task).unwrap();
    }
    // drop 发送端,通知 worker 没有更多任务了
    drop(task_tx);

    // 收集结果
    let mut results = Vec::new();
    for result in result_rx {
        println!("[{:>4}ms] 结果: Worker{} 完成任务{} - {}",
            start.elapsed().as_millis(),
            result.worker_id, result.task_id, result.output);
        results.push(result);
    }

    // 等待所有 worker 完成
    for h in worker_handles {
        h.join().unwrap();
    }

    println!("\n=== 汇总 ===");
    println!("完成任务: {}个", results.len());
    println!("总耗时: {:?}", start.elapsed());

    // 统计每个 worker 完成了多少任务
    for wid in 0..num_workers {
        let count = results.iter().filter(|r| r.worker_id == wid).count();
        println!("Worker {}: {}个任务", wid, count);
    }
}

常见问题 ​

问题一:发送引用可以吗?

通道要求数据满足 Send + 'static。局部变量的引用不满足 'static,所以不能直接发送。可以发送 Arc<T> 来共享数据,或者发送拥有所有权的值。

问题二:send 会复制数据吗?

对于 Vec、String 等堆上数据,send 只移动了栈上的指针/长度/容量,不复制堆上的实际数据。对于 Copy 类型,send 复制值。总的来说,send 的成本很低。

问题三:发送失败时数据会丢失吗?

不会。send() 返回 Err(SendError<T>),其中包含了发送失败的值。可以通过 error.0 取回。

问题四:怎么在通道中传递不同类型的数据?

定义一个枚举,将不同类型包装在枚举的不同变体中,通过同一个 mpsc::channel::<MyEnum>() 发送。

适用场景 ​

  • 线程间安全传递数据:利用所有权转移避免数据竞争
  • 流水线处理:数据沿通道链依次传递
  • 工作窃取:多个 worker 从同一个通道获取任务
  • 结果收集:worker 将结果发回主线程

注意事项 ​

  • send 转移所有权,发送后原变量不可用(非 Copy 类型)
  • Copy 类型发送后原变量仍可用(复制了一份)
  • 大型数据发送不复制堆内容,只移动指针
  • SendError 包含未发送成功的值,可以取回
  • 共享只读大数据用 Arc,避免复制
  • 通道保证同一时刻只有一方拥有数据

总结 ​

通道通过所有权转移实现线程间安全的数据传递。send(value) 将 value 的所有权从发送方转移到通道,recv() 再从通道转移到接收方。对于非 Copy 类型,发送后原变量不可用;对于 Copy 类型,会复制一份。这种机制从编译期保证了同一时刻只有一个线程拥有数据,杜绝了数据竞争。大型堆数据(Vec、String)的 send 只移动指针,不复制实际数据。共享只读大数据用 Arc 避免重复分配。数据可以通过多个通道在多个线程间链式传递。