crossbeam-channel 全面指南:用 Rust 实现高性能多生产者多消费者消息传递

原创2026-10-13 19:36:224,368 阅读
文章标签:并发编程内存管理

crossbeam-channel 全面指南:用 Rust 实现高性能多生产者多消费者消息传递

导读

本文围绕 crossbeam 仓库中的 crossbeam-channel 子 crate(README)展开,系统讲解这套多生产者多消费者(MPMC)消息通道的核心概念、完整 API、底层实现原理与性能基准测试方法。读完本文,你将掌握 bounded / unbounded / 零容量通道的选用、Sender / Receiver 的多线程共享、select! 宏与 Select 动态选择、after / tick / never 等特殊通道,以及通道断连和各类错误处理的实战细节,并能在自己的 Rust 并发项目中直接落地使用。

crossbeam-channel 基准测试结果对比图(benchmarks/plot.png)

一、认识 crossbeam-channel:MPMC 消息传递的 Rust 解决方案

crossbeam-channel 是一个提供多生产者多消费者(Multi-Producer Multi-Consumer)通道的 crate,用于线程间消息传递,是标准库 std::sync::mpsc] 的替代方案——在功能上更丰富、性能上更优。该 crate 的定位在 [crossbeam-channel/src/lib.rs 的开篇文档中直接声明:"This crate is an alternative to std::sync::mpsc with more features and better performance."

其核心特性如下(均来自 README 的 Highlights 列表):

  • Sender 与 Receiver 均可克隆并在线程间共享:同一通道可以拥有多个发送端和多个接收端,这是它区别于标准库 mpsc(单生产者)的关键能力。
  • 两种主要通道类型:[bounded](有界通道)与 [unbounded](无界通道)。
  • 便捷的特殊通道:[after](定时投递一条消息)、[never](永不投递)、[tick](周期性投递)。
  • select! 宏:可以同时阻塞等待多个通道操作,任意一个就绪即执行。
  • Select 结构体:支持在运行时动态构建通道操作列表进行选择。
  • 极少的锁使用:通道实现极少加锁,以换取最大性能(详见性能基准一节)。

std::sync::mpsc]、[Sender]、[Receiver]、[bounded]、[unbounded]、[after]、[never]、[tick]、[select!]、[Select] 这些 API 的完整说明与示例代码,可在 [crossbeam-channel/src/lib.rs 的模块级文档中查看,本文后续章节将结合源码逐一深入。

二、快速开始:在 Cargo.toml 中引入依赖

在项目 Cargo.toml 中加入以下依赖即可开始使用:

[dependencies]
crossbeam-channel = "0.5"

当前仓库中 crossbeam-channel 的版本为 0.5.17(见 crossbeam-channel/Cargo.toml),edition = "2021",并依赖 crossbeam-utils(启用 atomic feature)。

一个最经典的 Hello World 示例(取自 lib.rs):

use crossbeam_channel::unbounded;

// 创建一个无界通道
let (s, r) = unbounded();

// 向通道发送一条消息
s.send("Hello, world!").unwrap();

// 从通道接收消息
assert_eq!(r.recv(), Ok("Hello, world!"));

编译前提:crossbeam-channel 需要 Rust 1.74 及以上版本(MSRV,见下文"兼容性"一节),低于该版本将无法编译。

三、通道类型:bounded、unbounded 与零容量通道

3.1 bounded:有界通道

bounded(cap) 创建一个有界通道,它最多同时容纳 cap 条消息。当通道已满时,发送操作会阻塞(或返回错误),直到有接收操作取走消息腾出空间。

use crossbeam_channel::bounded;

// 创建一个最多容纳 5 条消息的通道
let (s, r) = bounded(5);

// 连续发送 5 条消息不会阻塞
for i in 0..5 {
    s.send(i).unwrap();
}

// 第 6 次发送会阻塞,因为通道已满
// s.send(5).unwrap();

3.2 unbounded:无界通道

unbounded() 创建一个无界通道,缓冲区可增长,任意时刻可容纳任意数量的消息,发送永远不会因容量不足而阻塞:

use crossbeam_channel::unbounded;

let (s, r) = unbounded();

// 可以无阻塞地发送任意数量消息
for i in 0..1000 {
    s.send(i).unwrap();
}

3.3 零容量通道(rendezvous)

bounded(0) 创建的零容量通道是特殊情况:它不能缓冲任何消息,发送与接收操作必须同时出现才能配对并完成消息传递,因此得名 rendezvous(会合通道)。发送会阻塞直到对侧出现接收操作,反之亦然:

use std::thread;
use crossbeam_channel::bounded;

// 创建零容量通道
let (s, r) = bounded(0);

// 发送会阻塞,直到对侧出现接收操作
thread::spawn(move || s.send("Hi!").unwrap());

// 接收会阻塞,直到对侧出现发送操作
assert_eq!(r.recv(), Ok("Hi!"));

3.4 从源码看三种通道的实现

在 crossbeam-channel/src/channel.rs 中,bounded 函数的实现会按容量分支到不同的底层实现:

pub fn bounded<T>(cap: usize) -> (Sender<T>, Receiver<T>) {
    if cap == 0 {
        // 零容量:zero flavor(rendezvous 通道)
        ...
    } else {
        // 正容量:array flavor(预分配数组的有界队列)
        ...
    }
}

而 unbounded() 则固定使用 list flavor(链表实现的无界通道)。这三种 flavor 与 at、tick、never 共同构成了 crate 的六大通道风味,定义在 crossbeam-channel/src/flavors/mod.rs:

  1. at —— 在某个时刻投递一条消息的通道;
  2. array —— 基于预分配数组的有界通道;
  3. list —— 链表实现的无界通道;
  4. never —— 永不投递消息的通道;
  5. tick —— 周期性投递消息的通道;
  6. zero —— 零容量(会合)通道。

其中 array flavor 的实现基于 Dmitry Vyukov 的无锁有界 MPMC 队列设计(见 crossbeam-channel/src/flavors/array.rs 源码注释),使用 CachePadded<AtomicIndex> 类型的 head / tail 指针与"stamp"(索引 + lap + mark 位打包)机制进行无锁并发控制;list flavor 则按 32 个索引为一"lap"分配链表块(BLOCK_CAP = LAP - 1 = 31),每个槽位用 WRITE / READ / DESTROY 三个状态位标记(见 crossbeam-channel/src/flavors/list.rs);zero flavor 通过栈上或堆上的 Packet 在发送方与接收方之间直接传递消息(见 crossbeam-channel/src/flavors/zero.rs)。

注意:bounded(cap) 在 cap 过大、无法完成初始化时会 panic(channel.rs 中通过 checked arithmetic 断言"bounded channel capacity is too large"),使用时应注意容量上限。

四、Sender 与 Receiver:克隆、共享与跨线程传递

4.1 克隆只会创建"同侧"的新句柄

Sender 和 Receiver 都可以通过 clone() 复制,但克隆只是为同一通道的发送侧或接收侧创建新的句柄,绝不会产生独立的、可分别读取的消息流。这一点在 lib.rs 的文档示例中有清晰演示:

use crossbeam_channel::unbounded;

let (s1, r1) = unbounded();
let (s2, r2) = (s1.clone(), r1.clone());
let (s3, r3) = (s2.clone(), r2.clone());

s1.send(10).unwrap();
s2.send(20).unwrap();
s3.send(30).unwrap();

// 所有接收端读到的都是同一条消息流
assert_eq!(r3.recv(), Ok(10));
assert_eq!(r1.recv(), Ok(20));
assert_eq!(r2.recv(), Ok(30));

4.2 通过 move 或引用共享

句柄可以 move 进线程闭包,也可以借助 crossbeam_utils::thread::scope 按引用共享:

use std::thread;
use crossbeam_channel::bounded;

let (s1, r1) = bounded(0);
let (s2, r2) = (s1.clone(), r1.clone());

// 子线程:先接收一条消息,再发送一条
thread::spawn(move || {
    r2.recv().unwrap();
    s2.send(2).unwrap();
});

// 主线程:发送一条,再接收一条
s1.send(1).unwrap();
r1.recv().unwrap();

按引用共享的写法(需要 crossbeam-utils):

use crossbeam_channel::bounded;
use crossbeam_utils::thread::scope;

let (s, r) = bounded(0);

scope(|scope| {
    scope.spawn(|_| {
        r.recv().unwrap();
        s.send(2).unwrap();
    });
    s.send(1).unwrap();
    r.recv().unwrap();
}).unwrap();

4.3 从源码看句柄的引用计数

从源码结构看,Sender / Receiver 内部各自持有一个 SenderFlavor / ReceiverFlavor,其中 Array / List / Zero 三种 flavor 指向 crossbeam-channel/src/counter.rs 中实现的引用计数器 Counter。计数器维护 senders / receivers 两个原子计数,acquire() 用于克隆时计数加一(超过 isize::MAX 时直接 process::abort() 防止溢出),release() 用于 drop 时计数减一并在最后一个引用释放时销毁通道。clone 与 Drop 的实现见 channel.rs 中的 impl<T> Clone for Sender<T> 与 impl<T> Drop for Sender<T>。

另外,Sender / Receiver 都提供了 same_channel(&self, other) 方法用于判断两个句柄是否属于同一通道(At / Tick 风味通过 Arc::ptr_eq 比较,Never 风味恒为 true),以及 is_empty()、is_full()、len()、capacity() 等状态查询方法。值得注意:零容量通道永远为空、永远为满(capacity() 返回 Some(0)),而无界通道的 capacity() 返回 None。

五、通道生命周期与断连(Disconnection)

当通道关联的所有发送端或所有接收端被 drop 时,通道即进入断连状态:不能再发送新消息,但缓冲区中残留的消息仍然可以被接收。断连通道上的发送与接收操作永远不会阻塞。

use crossbeam_channel::{unbounded, RecvError};

let (s, r) = unbounded();
s.send(1).unwrap();
s.send(2).unwrap();
s.send(3).unwrap();

// 唯一发送端被 drop,通道断连
drop(s);

// 残留消息仍可接收
assert_eq!(r.recv(), Ok(1));
assert_eq!(r.recv(), Ok(2));
assert_eq!(r.recv(), Ok(3));

// 通道内已无消息
assert!(r.is_empty());

// 注意:此时 r.recv() 不阻塞,而是立即返回 Err(RecvError)
assert_eq!(r.recv(), Err(RecvError));

从源码看,Sender 的 Drop 实现会调用 disconnect_senders()(zero 风味为 disconnect()),Receiver 的 Drop 则调用 disconnect_receivers()(见 channel.rs 中两个 Drop 实现)。At / Tick / Never 风味不会因 drop 而断连(它们的 Drop 为空操作)。

六、发送与接收的三类操作形态

发送和接收操作都有三种形态(lib.rs):

形态 发送 API 接收 API 行为
非阻塞 try_send try_recv 立即返回成功或失败
阻塞 send recv 一直等待,直到操作成功或通道断连
带超时阻塞 send_timeout / send_deadline recv_timeout / recv_deadline 只阻塞一段时长或直到某个截止时刻

以下示例(取自 lib.rs)演示了非阻塞与阻塞操作的差异:

use crossbeam_channel::{bounded, RecvError, TryRecvError};

let (s, r) = bounded(1);

// 发送一条消息
s.send("foo").unwrap();

// 通道已满,此调用会阻塞
// s.send("bar").unwrap();

// 接收消息
assert_eq!(r.recv(), Ok("foo"));

// 通道已空,此调用会阻塞
// r.recv();

// 非阻塞接收:立即返回 Err(TryRecvError::Empty)
assert_eq!(r.try_recv(), Err(TryRecvError::Empty));

// 断连通道
drop(s);

// 断连后不阻塞,立即返回 Err(RecvError)
assert_eq!(r.recv(), Err(RecvError));

带超时的接收示例:

use std::thread;
use std::time::Duration;
use crossbeam_channel::{unbounded, RecvTimeoutError};

let (s, r) = unbounded();

thread::spawn(move || {
    thread::sleep(Duration::from_secs(1));
    s.send(5).unwrap();
    drop(s);
});

// 500ms 超时,此时还没有消息
assert_eq!(r.recv_timeout(Duration::from_millis(500)), Err(RecvTimeoutError::Timeout));

// 1s 后收到消息
assert_eq!(r.recv_timeout(Duration::from_secs(1)), Ok(5));

// 通道已断连且为空
assert_eq!(r.recv_timeout(Duration::from_secs(1)), Err(RecvTimeoutError::Disconnected));

错误类型速查

完整的错误类型定义在 crossbeam-channel/src/err.rs,所有携带消息的错误都可通过 into_inner() 取回原消息:

  • SendError<T>:send 在通道断连时返回,包含原消息;
  • TrySendError<T>:try_send 的失败类型,分 Full(T)(通道满)与 Disconnected(T)(断连),可用 is_full() / is_disconnected() 判断;
  • SendTimeoutError<T>:send_timeout / send_deadline 的失败类型,分 Timeout(T)(超时)与 Disconnected(T);
  • RecvError:recv 在通道为空且断连时返回;
  • TryRecvError:try_recv 的失败类型,分 Empty(为空)与 Disconnected(为空且断连);
  • RecvTimeoutError:recv_timeout / recv_deadline 的失败类型,分 Timeout 与 Disconnected。

此外还有与 Select 相关的 TrySelectError、SelectTimeoutError、TryReadyError、ReadyTimeoutError(详见第九节)。

实现细节:send_timeout 与 recv_timeout 内部通过 Instant::now().checked_add(timeout) 将相对时长换算为绝对截止时刻 deadline,再调用 send_deadline / recv_deadline;若换算溢出(None),则退化为无限期阻塞的 send / recv(见 channel.rs)。超时语义有一个值得注意的细节:如果超时已过但通道不空,消息仍会被返回(文档原文 "If the channel is non-empty and the timeout has already elapsed, the next message in the channel will be returned")。

七、迭代器:iter、try_iter 与 into_iter

Receiver 可以直接当作迭代器使用,共有三种形态(channel.rs):

  • iter()(阻塞迭代):每次 next 阻塞等待下一条消息;当通道为空且断连时返回 None。注意迭代可能在等待消息时阻塞。
  • try_iter()(非阻塞迭代):只接收当前已就绪的消息,绝不阻塞。
  • into_iter()(所有权迭代):消费 Receiver 本身,行为同 iter();&Receiver 也实现了 IntoIterator。

阻塞迭代示例:

use std::thread;
use crossbeam_channel::unbounded;

let (s, r) = unbounded();

thread::spawn(move || {
    s.send(1).unwrap();
    s.send(2).unwrap();
    s.send(3).unwrap();
    drop(s); // 断连,让迭代终止
});

// collect 会阻塞,直到发送端被 drop
let v: Vec<_> = r.iter().collect();
assert_eq!(v, [1, 2, 3]);

非阻塞迭代示例(无需 drop 发送端):

use crossbeam_channel::unbounded;

let (s, r) = unbounded();
s.send(1).unwrap();
s.send(2).unwrap();
s.send(3).unwrap();

// 只接收当前已在通道中的消息,不阻塞
let v: Vec<_> = r.try_iter().collect();
assert_eq!(v, [1, 2, 3]);

从源码看,Iter / TryIter / IntoIter 的 next() 分别内部调用 receiver.recv().ok() 或 receiver.try_recv().ok();其中 Iter 与 IntoIter 还实现了 FusedIterator(一旦返回 None 即为终止状态,不再调用底层通道)。

八、select! 宏:一次等待多个通道操作

select! 宏允许你定义一组通道操作,阻塞等待直到其中任意一个就绪,然后执行它。如果多个操作同时就绪,则从中随机选择一个(源码层面体现在 run_select 中对句柄列表调用 utils::shuffle(handles) 打乱顺序以实现公平性,见 crossbeam-channel/src/select.rs)。操作"就绪"的定义是该操作无需阻塞——注意,即使操作因通道断连而会返回错误,也算作就绪。

select! 还支持 default 分支:当没有任何操作就绪时执行;default 分支可以带时长参数,表示"等待这么长时间后就执行 default"。

从两个通道接收消息的示例(lib.rs):

use std::thread;
use std::time::Duration;
use crossbeam_channel::{select, unbounded};

let (s1, r1) = unbounded();
let (s2, r2) = unbounded();

thread::spawn(move || s1.send(10).unwrap());
thread::spawn(move || s2.send(20).unwrap());

// 这两个接收操作至多只会执行一个
select! {
    recv(r1) -> msg => assert_eq!(msg, Ok(10)),
    recv(r2) -> msg => assert_eq!(msg, Ok(20)),
    default(Duration::from_secs(1)) => println!("timed out"),
}

select! 支持的操作包括:

  • recv(r) -> msg => ...:从接收端 r 接收,msg 为 Result<T, RecvError>;
  • send(s, msg) -> res => ...:向发送端 s 发送,res 为 Result<(), SendError<T>>;
  • default => ... 或 default(Duration) => ...:无操作就绪时的兜底分支。

宏的内部结构:select! 只是围绕 Select 结构体的"便捷包装"。其实现位于 crossbeam-channel/src/select_macro.rs,宏分为两个阶段——解析阶段(@list / @case 把 token 列表解析为 case 列表并做语法诊断,语法错误会在编译期报出)与代码生成阶段(@init / @count / @add / @complete 初始化句柄列表、统计 case 数、加入发送/接收操作并开始选择、最后完成所选操作)。宏展开后依赖 crossbeam_channel::internal 模块(在 lib.rs 中 re-export 了 select、select_timeout、try_select、sender_addr、receiver_addr 等内部函数)。

九、Select 结构体:动态构建选择列表

当操作列表需要在运行时动态构建(例如数量不固定、来自循环)时,应使用 Select 结构体而不是 select! 宏。Select 在 crossbeam-channel/src/select.rs 中实现,其典型用法(来自 crossbeam-channel/tests/select.rs 的测试用例):

use crossbeam_channel::{Select, unbounded};

let (s1, r1) = unbounded::<usize>();
let (s2, r2) = unbounded::<usize>();

s1.send(1).unwrap();

// 动态构建选择列表
let mut sel = Select::new();
let oper1 = sel.recv(&r1);
let oper2 = sel.recv(&r2);
let oper = sel.select();

// 根据选中的操作索引分发执行
match oper.index() {
    i if i == oper1 => assert_eq!(oper.recv(&r1), Ok(1)),
    i if i == oper2 => panic!(),
    _ => unreachable!(),
}

Select 提供了与 select! 三形态对应的 API 家族:select()(无限阻塞)、try_select()(立即返回,失败时返回 TrySelectError)、select_timeout(Duration)(失败时返回 SelectTimeoutError),以及只等待"就绪"而不真正执行操作的 ready() / try_ready() / ready_timeout()(对应错误 TryReadyError / ReadyTimeoutError)。添加操作的方法包括 recv(&r)、send(&s)、recv_timeout(...)、send_timeout(...)、recv_deadline(...)、send_deadline(...) 等,返回操作句柄,最后通过 SelectedOperation 上的 index()、recv(&r)、send(&s) 完成执行。

从源码看选择机制

在 select.rs 中,选择的核心是 run_select 函数与 SelectHandle trait。SelectHandle 抽象了"一个可以参与选择的操作"(Sender / Receiver 均实现了该 trait,见 channel.rs),其关键方法包括:

  • try_select(&self, token: &mut Token) -> bool:尝试无阻塞地完成一次操作;
  • deadline(&self) -> Option<Instant>:返回该操作自身的截止时刻(At / Tick 风味会返回投递时刻,普通通道返回 None);
  • register / unregister:阻塞等待期间的注册与注销;
  • accept:被唤醒后确认所选操作;
  • watch / unwatch:就绪通知。

选择流程(run_select)大致为:先对所有操作做一轮无阻塞 try_select;失败后进入循环——在 Context 中注册所有操作、计算最早截止时刻(取各操作 deadline() 与超时时刻的较小值)、wait_until 阻塞唤醒、注销操作、再尝试 accept 或再试一轮 try_select。Token 结构体则为各 flavor 保存"预留槽位"的临时数据,供随后的 channel::read / channel::write 完成实际消息搬运。

十、特殊通道:after、at、tick 与 never

三个便捷函数可以创建特殊通道,它们只返回 Receiver 句柄(无发送端):

  • after(duration):经过 duration 时长后投递恰好一条消息,消息内容是投递时刻的 Instant。容量为 1,永不断连。若换算投递时刻溢出(Instant::now().checked_add(duration) 返回 None),则退化为 never()。
  • at(when):在指定的 Instant 时刻投递一条消息(内容为投递时刻)。若 when 已过去,消息会立即投递。
  • tick(duration):每隔 duration 周期性地投递一条消息,内容为每次投递时刻的 Instant。容量为 1,永不断连。
  • never():容量为 0、永不投递任何消息、也永不断连的通道。常用于"可选超时"场景:把 Option<Duration> 映射为 after 或 never。

这些通道非常高效,因为消息是在接收操作时才惰性生成的(lib.rs 原文:"messages get lazily generated on receive operations")。从源码看,at 风味内部只保存 delivery_time 与一个 received: AtomicBool,try_recv 中一旦到达时刻即通过 swap(true, Ordering::SeqCst) 一次性交付(crossbeam-channel/src/flavors/at.rs)。

一个综合示例——每 50ms 打印一次耗时,持续 1 秒后退出(lib.rs):

use std::time::{Duration, Instant};
use crossbeam_channel::{after, select, tick};

let start = Instant::now();
let ticker = tick(Duration::from_millis(50));
let timeout = after(Duration::from_secs(1));

loop {
    select! {
        recv(ticker) -> _ => println!("elapsed: {:?}", start.elapsed()),
        recv(timeout) -> _ => break,
    }
}

never 用于"可选超时"的经典写法:

use std::thread;
use std::time::Duration;
use crossbeam_channel::{after, select, never, unbounded};

let (s, r) = unbounded();
thread::spawn(move || {
    thread::sleep(Duration::from_secs(1));
    s.send(1).unwrap();
});

// 假设这个时长可能是 Some 或 None
let duration = Some(Duration::from_millis(100));

// 有时长则用 after 超时,无时长则用 never(永不超时)
let timeout = duration
    .map(after)
    .unwrap_or_else(never);

select! {
    recv(r) -> msg => assert_eq!(msg, Ok(1)),
    recv(timeout) -> _ => println!("timed out"),
}

十一、性能与基准测试

README 强调通道"极少使用锁"以获得最大性能,本仓库的 crossbeam-channel/benchmarks 目录提供了完整的基准测试方案,结果图即本文开头的 plot.png。

基准测试场景

benchmarks/README.md 定义了六种测试模式:

  • seq:单线程先发送 N 条消息,再接收 N 条消息;
  • spsc:一个线程发送 N 条,另一个线程接收 N 条(单生产者单消费者);
  • mpsc:T 个线程各发送 N / T 条,一个线程接收 N 条(多生产者单消费者);
  • mpmc:T 个线程各发送 N / T 条,另有 T 个线程各接收 N / T 条(多生产者多消费者);
  • select_rx:T 个线程各自向独立的通道发送 N / T 条,另一个线程通过 select 在 T 个通道上接收 N 条;
  • select_both:T 个线程各自通过 select 在 T 个通道上发送 N / T 条,另 T 个线程通过 select 在 T 个通道上接收 N / T 条。

默认参数为 N = 5,000,000、T = 4。

运行方式

在 crossbeam-channel/benchmarks 目录下执行:

./run.sh

该脚本会运行全部基准测试、把结果写入 *.txt 文件并生成 plot.png 图表。依赖环境包括:Rust、Go、Bash、Python 与 Matplotlib。

说明:基准结果记录于 benchmarks/README.md,对应的测试环境为 Intel Core i7-5500U(2 物理核 / 4 逻辑核)、rustc 1.63.0、Go 1.19,仅反映特定历史环境下的数据,并非当前仓库代码的实测结论;如要复现,请在目标机器上自行运行 run.sh。

从实现角度佐证"极少锁"的设计:array / list flavor 的读写路径依赖原子 CAS(compare_exchange_weak)与 crossbeam_utils::Backoff 退避自旋,仅在需要阻塞唤醒时才通过 SyncWaker 参与(见 flavors/array.rs、flavors/list.rs);zero flavor 因需要精确配对发送与接收,使用 Waker 与内部 Mutex(见 flavors/zero.rs)。此外,head / tail 指针均用 CachePadded 填充以避免伪共享(false sharing)。

十二、仓库内实战示例

仓库 crossbeam-channel/examples 下提供了三个可直接运行的示例:

12.1 matching.rs:select! 同时收发

crossbeam-channel/examples/matching.rs 改编自 Stefan Nilsson 的 Go 并发示例 matching.go(见 README 的第三方软件声明):5 个参与者各自在线程中执行 select!,要么从通道接收他人名字、要么把自己的名字发送进通道,谁先发生执行谁。它演示了 select! 中 recv 与 send 分支混用,以及最终用 try_recv() 检查是否有未被配对的残留消息:

use crossbeam_channel::{bounded, select};
use crossbeam_utils::thread;

let people = vec!["Anna", "Bob", "Cody", "Dave", "Eva"];
let (s, r) = bounded(1); // 为一个未配对的发送预留空间

let seek = |name, s, r| {
    select! {
        recv(r) -> peer => println!("{} received a message from {}.", name, peer.unwrap()),
        send(s, name) -> _ => {}, // 等待某人接收我的消息
    }
};

thread::scope(|scope| {
    for name in people {
        let (s, r) = (s.clone(), r.clone());
        scope.spawn(move |_| seek(name, s, r));
    }
}).unwrap();

// 检查是否存在未配对的发送
if let Ok(name) = r.try_recv() {
    println!("No one received {}’s message.", name);
}

12.2 fibonacci.rs:零容量通道 + 异步计算

crossbeam-channel/examples/fibonacci.rs 演示了零容量通道(bounded(0))驱动的异步斐波那契序列生成器:生产者线程持续 send(每次都会与主线程的 recv 会合),主线程用 r.iter().take(20) 迭代消费前 20 个数字,send 在通道断连(接收端被 drop)时返回 Err 从而结束循环。

12.3 stopwatch.rs:tick + select 实现秒表

crossbeam-channel/examples/stopwatch.rs 组合使用 tick(每秒触发)与一个承载 SIGINT 信号的通道,通过 select! 实现"每秒打印耗时、按 Ctrl+C 退出"的秒表程序(Windows 平台不适用,代码中有 cfg(windows) 分支处理)。

十三、兼容性与版本策略

crossbeam-channel 遵循与 Crossbeam 系列一致的兼容性策略(README Compatibility 一节):

  • 支持至少一年以内的 stable Rust 版本;
  • 每当提升最低支持的 Rust 版本时,会同步发布一个新的 minor 版本;
  • 当前最低支持版本为 Rust 1.74,与 crossbeam-channel/Cargo.toml 中的 rust-version = "1.74" 及徽章 Rust 1.74+ 保持一致。

十四、许可说明

crossbeam-channel 采用双重许可(LICENSE-APACHE、LICENSE-MIT),使用者可任选其一:

  • Apache License, Version 2.0;
  • MIT License。

贡献者提交的代码默认按上述双重许可授权。此外,该 crate 还包含第三方软件的复制与修改,相关许可证文本集中在 LICENSE-THIRD-PARTY:

  • examples/matching.rs 包含 Stefan Nilsson 编写的 matching.go(Creative Commons Attribution 3.0 Unported License);
  • tests/mpsc.rs 包含来自 The Rust Programming Language 的代码修改(MIT / Apache-2.0 双许可);
  • tests/golang.rs 基于 Go 编程语言代码(3-Clause BSD License)。

结语

crossbeam-channel 以六大 flavor 架构(array / list / zero / at / tick / never)为骨架,配合引用计数句柄、无锁原子队列与 select 选择机制,为 Rust 并发编程提供了比 std::sync::mpsc 更灵活、更高效的 MPMC 通道能力。无论是固定容量的有界队列、无限增长的无界队列,还是需要多方汇聚的会合通道与多通道竞争选择,都可以在本文所述 API 中找到对应的实战方案。进一步阅读可直接查阅 crossbeam-channel/src/lib.rs 的模块文档、crossbeam-channel/tests 下的各测试文件(如 select.rs、array.rs、list.rs、mpsc.rs),以及 benchmarks/README.md 了解完整的性能验证方法。

登录后查看全文
crossbeam