同步通道 sync_channel ​

核心概念 ​

mpsc::sync_channel(bound) 创建一个有界的同步通道,缓冲区最多容纳 bound 条消息。当缓冲区满时,send() 会阻塞发送线程,直到接收方取走一条消息腾出空间。这和无界通道(mpsc::channel())的关键区别在于:无界通道的 send() 永远不会阻塞(缓冲区会无限增长),而同步通道通过阻塞发送方来实现背压(backpressure),防止生产者速度远超消费者导致内存无限增长。sync_channel(0) 是特殊情况——缓冲区为零,每次 send 都必须等到对方 recv 才能完成,实现了严格的"握手"同步。

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

fn main() {
    // 创建容量为 2 的同步通道
    let (tx, rx) = mpsc::sync_channel(2);

    thread::spawn(move || {
        for i in 1..=5 {
            println!("发送 {}...", i);
            tx.send(i).unwrap();  // 缓冲区满时会阻塞
            println!("发送 {} 完成", i);
        }
    });

    // 故意慢速接收,观察发送方的阻塞
    for _ in 0..5 {
        thread::sleep(Duration::from_millis(300));
        let val = rx.recv().unwrap();
        println!("  接收: {}", val);
    }
}

sync_channel 与 channel 的对比 ​

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

fn main() {
    // === 无界通道:send 永不阻塞 ===
    let (tx, rx) = mpsc::channel();
    let start = Instant::now();

    let producer = thread::spawn(move || {
        for i in 0..5 {
            tx.send(i).unwrap();
            println!("[{:>4}ms] 无界 send {}", start.elapsed().as_millis(), i);
        }
        // 所有 send 立即完成
    });

    thread::sleep(Duration::from_millis(500));
    producer.join().unwrap();

    while let Ok(v) = rx.try_recv() {
        println!("  无界 recv: {}", v);
    }

    // === 同步通道(容量1):send 可能阻塞 ===
    let (tx, rx) = mpsc::sync_channel(1);
    let start = Instant::now();

    let producer = thread::spawn(move || {
        for i in 0..5 {
            println!("[{:>4}ms] 同步 send {}...", start.elapsed().as_millis(), i);
            tx.send(i).unwrap();  // 缓冲区满时阻塞
            println!("[{:>4}ms] 同步 send {} 完成", start.elapsed().as_millis(), i);
        }
    });

    // 慢速接收
    for _ in 0..5 {
        thread::sleep(Duration::from_millis(200));
        let val = rx.recv().unwrap();
        println!("[{:>4}ms]   同步 recv: {}", start.elapsed().as_millis(), val);
    }

    producer.join().unwrap();
}
特性channel()(无界)sync_channel(n)(有界)
缓冲区无限增长最多 n 条
send() 阻塞永不阻塞缓冲区满时阻塞
内存控制无(可能 OOM)有背压限制
发送端类型Sender<T>SyncSender<T>
try_send()无有(非阻塞)
适用场景突发流量、低延迟流量控制、稳定内存

零容量通道(Rendezvous Channel) ​

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

fn main() {
    // sync_channel(0):缓冲区为零
    // send 必须等到 recv 准备好才能完成
    let (tx, rx) = mpsc::sync_channel(0);
    let start = Instant::now();

    thread::spawn(move || {
        for i in 1..=3 {
            println!("[{:>4}ms] send {}...",
                start.elapsed().as_millis(), i);
            tx.send(i).unwrap();
            // send 在 recv 取走数据后才返回
            println!("[{:>4}ms] send {} 完成(对方已接收)",
                start.elapsed().as_millis(), i);
        }
    });

    for _ in 0..3 {
        thread::sleep(Duration::from_millis(300));
        println!("[{:>4}ms] 准备接收...", start.elapsed().as_millis());
        let val = rx.recv().unwrap();
        println!("[{:>4}ms]   recv: {}", start.elapsed().as_millis(), val);
    }

    // 零容量通道实现了严格的同步握手
    // 发送方和接收方在每次传递时都"会合"
}

try_send 非阻塞发送 ​

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

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

    // 先填满缓冲区
    tx.send(1).unwrap();
    tx.send(2).unwrap();

    // try_send:缓冲区满时立即返回错误,不阻塞
    match tx.try_send(3) {
        Ok(()) => println!("try_send 成功"),
        Err(mpsc::TrySendError::Full(val)) => {
            println!("缓冲区已满,值 {} 未发送", val);
            // 可以取回未发送的值
        }
        Err(mpsc::TrySendError::Disconnected(val)) => {
            println!("通道已关闭,值 {} 未发送", val);
        }
    }

    // 接收一个后再 try_send
    let _ = rx.recv().unwrap();
    match tx.try_send(3) {
        Ok(()) => println!("try_send 成功"),
        Err(e) => println!("try_send 失败: {:?}", e),
    }

    // 接收所有
    drop(tx);
    for val in rx {
        println!("收到: {}", val);
    }

    // 实际场景:用 try_send 实现非阻塞日志
    let (log_tx, log_rx) = mpsc::sync_channel(100);

    // 日志写入线程
    let writer = thread::spawn(move || {
        for msg in log_rx {
            println!("[日志] {}", msg);
        }
    });

    // 业务代码中非阻塞写入日志
    for i in 0..5 {
        match log_tx.try_send(format!("事件 {}", i)) {
            Ok(()) => {} // 成功
            Err(mpsc::TrySendError::Full(_)) => {
                // 日志缓冲区满,丢弃这条日志
                eprintln!("日志缓冲区满,丢弃");
            }
            Err(_) => break,
        }
    }
    drop(log_tx);
    writer.join().unwrap();
}

基本示例 ​

用同步通道实现带背压的流水线:

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

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

    // 三阶段流水线,每阶段的同步通道限制缓冲
    let (raw_tx, raw_rx) = mpsc::sync_channel::<String>(2);
    let (processed_tx, processed_rx) = mpsc::sync_channel::<String>(2);
    let (final_tx, final_rx) = mpsc::sync_channel::<String>(2);

    // 阶段1:数据采集(快速)
    let s = start.clone();
    let collector = thread::spawn(move || {
        let items = vec![
            "原始数据A", "原始数据B", "原始数据C",
            "原始数据D", "原始数据E", "原始数据F",
        ];
        for item in items {
            println!("[{:>4}ms] 采集: {}", s.elapsed().as_millis(), item);
            raw_tx.send(item.to_string()).unwrap();
            thread::sleep(Duration::from_millis(50));
        }
    });

    // 阶段2:数据处理(中速)
    let s = start.clone();
    let processor = thread::spawn(move || {
        for raw in raw_rx {
            thread::sleep(Duration::from_millis(150));  // 处理耗时
            let result = format!("[已处理] {}", raw);
            println!("[{:>4}ms] 处理: {}", s.elapsed().as_millis(), result);
            processed_tx.send(result).unwrap();
        }
    });

    // 阶段3:数据存储(慢速)
    let s = start.clone();
    let writer = thread::spawn(move || {
        for data in processed_rx {
            thread::sleep(Duration::from_millis(200));  // 写入耗时
            let saved = format!("[已保存] {}", data);
            println!("[{:>4}ms] 存储: {}", s.elapsed().as_millis(), saved);
            final_tx.send(saved).unwrap();
        }
    });

    // 收集最终结果
    let results: Vec<String> = final_rx.into_iter().collect();

    collector.join().unwrap();
    processor.join().unwrap();
    writer.join().unwrap();

    println!("\n=== 最终结果 ({} 条) ===", results.len());
    for r in &results {
        println!("  {}", r);
    }
    println!("总耗时: {:?}", start.elapsed());

    // 对比:如果不限制缓冲区
    // 采集线程会瞬间把所有数据塞进通道
    // 内存使用不可控
    // 同步通道让快的阶段等慢的阶段,内存使用稳定

    // === 容量选择的影响 ===
    println!("\n=== 容量测试 ===");
    for cap in [0, 1, 5, 100] {
        let (tx, rx) = mpsc::sync_channel(cap);
        let s = Instant::now();

        let producer = thread::spawn(move || {
            for i in 0..10 {
                tx.send(i).unwrap();
            }
        });

        // 短暂延迟后接收
        thread::sleep(Duration::from_millis(50));
        let received: Vec<i32> = rx.into_iter().collect();
        producer.join().unwrap();

        println!("  容量={}: 耗时={:?}, 收到={:?}",
            cap, s.elapsed(), received.len());
    }
}

常见问题 ​

问题一:sync_channel 的容量应该设多大?

取决于生产和消费的速度差。容量太小会频繁阻塞生产者,容量太大失去背压的意义。一般从小容量开始(如 10-100),根据性能测试调整。容量为 0 实现严格同步。

问题二:sync_channel 和 channel 该用哪个?

如果生产者速度可能远超消费者,用 sync_channel 防止内存无限增长。如果生产者是突发性的、消费者能及时消费,用 channel 避免不必要的阻塞。

问题三:SyncSender 和 Sender 有什么区别?

SyncSender 是 sync_channel 返回的发送端,多了 try_send() 方法。Sender 是 channel 返回的发送端,没有 try_send(因为 send 永不阻塞,不需要非阻塞版本)。两者都可以 clone。

问题四:sync_channel 的 send 阻塞时线程在做什么?

线程处于内核等待状态,不消耗 CPU。当接收方取走消息后,发送方被唤醒继续执行。

适用场景 ​

  • 背压控制:防止快速生产者压垮慢速消费者
  • 内存限制:限制通道中积压的消息数量
  • 流水线:多阶段处理中控制各阶段的速度匹配
  • 严格同步:sync_channel(0) 实现握手式同步

注意事项 ​

  • sync_channel(n) 的 send 在缓冲区满时阻塞
  • sync_channel(0) 的 send 总是阻塞直到对方 recv
  • 返回的是 SyncSender(不是 Sender),多了 try_send
  • try_send 缓冲区满时返回 TrySendError::Full(value)
  • SyncSender 也可以 clone 实现多生产者
  • 容量过小会降低吞吐,容量过大失去背压作用

总结 ​

mpsc::sync_channel(bound) 创建有界同步通道,缓冲区最多 bound 条消息。缓冲区满时 send() 阻塞发送方,实现背压控制。sync_channel(0) 是零缓冲,每次 send 必须等 recv 才能完成(握手同步)。返回的发送端是 SyncSender,额外提供 try_send() 非阻塞发送(缓冲满时返回 Full(value))。同步通道适合生产速度可能远超消费速度的场景,通过阻塞来防止内存无限增长。无界通道 channel() 的 send 永不阻塞但缓冲区可能无限增长。容量的选择需要在吞吐量和内存使用之间权衡。