通道所有权转移
核心概念
通道传递数据时执行的是所有权转移(move),而不是拷贝或共享。send(value) 之后,发送方不再拥有 value,接收方通过 recv() 获得完整的所有权。这是 Rust 所有权系统在并发场景中的自然延伸——通过转移所有权来保证同一时刻只有一个线程拥有数据,从根本上避免了数据竞争。对于 Copy 类型(如 i32),send 实际上是复制了一份;对于非 Copy 类型(如 String、Vec),send 后原变量就不能再使用了。
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 现在完全属于主线程
}所有权转移的意义
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 类型的区别
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 仍可用 | 共享只读数据 |
发送大型数据的策略
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);
}
}通道中所有权转移的连锁传递
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 的所有权转移
}基本示例
用通道所有权转移实现一个安全的工作窃取模式:
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 避免重复分配。数据可以通过多个通道在多个线程间链式传递。