Struct std::sync::mpsc::Receiver

pub struct Receiver<T> { /* fields omitted */ }

Rust 的 channel (或 sync_channel) 类型的接收一半。 这一半只能由一个线程拥有。

可以使用 recv 检索发送到通道的消息。

Examples

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

let (send, recv) = channel();

thread::spawn(move || {
    send.send("Hello world!").unwrap();
    thread::sleep(Duration::from_secs(2)); // 阻塞两秒钟
    send.send("Delayed for 2 seconds").unwrap();
});

println!("{}", recv.recv().unwrap()); // 立即收到
println!("Waiting...");
println!("{}", recv.recv().unwrap()); // 2 秒后收到

Implementations

impl<T> Receiver<T>

pub fn try_recv(&self) -> Result<T, TryRecvError>

尝试在不阻塞的情况下在此接收者上返回挂起的值。

此方法决不会阻塞调用方，以等待数据可用。 取而代之的是，它总是立即返回，并可能在通道上保留未决数据。

在决定阻塞接收者之前，这对于 “optimistic check” 很有用。

与 recv 相比，此函数有两种故障情况，而不是一种情况 (一种情况是断开连接，一种情况是空缓冲区)。

Examples

use std::sync::mpsc::{Receiver, channel};

let (_, receiver): (_, Receiver<i32>) = channel();

assert!(receiver.try_recv().is_err());

pub fn recv(&self) -> Result<T, RecvError>

尝试等待此接收者上的值，如果相应的通道已挂起，则返回错误。

如果没有可用数据并且有可能发送更多数据 (至少一个发送者仍然存在)，此函数将始终阻塞当前线程。 一旦消息发送到相应的 Sender (或 SyncSender)，该接收者将唤醒并返回该消息。

如果相应的 Sender 断开连接，或者在此调用阻塞时断开连接，则此调用将唤醒并返回 Err，以指示该通道上再也不会收到任何消息。

但是，由于缓冲了通道，因此在断开连接之前发送的消息仍将被正确接收。

Examples

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

let (send, recv) = mpsc::channel();
let handle = thread::spawn(move || {
    send.send(1u8).unwrap();
});

handle.join().unwrap();

assert_eq!(Ok(1), recv.recv());

缓冲行为:

use std::sync::mpsc;
use std::thread;
use std::sync::mpsc::RecvError;

let (send, recv) = mpsc::channel();
let handle = thread::spawn(move || {
    send.send(1u8).unwrap();
    send.send(2).unwrap();
    send.send(3).unwrap();
    drop(send);
});

// 等待线程加入，因此我们确保发送者已被丢弃
handle.join().unwrap();

assert_eq!(Ok(1), recv.recv());
assert_eq!(Ok(2), recv.recv());
assert_eq!(Ok(3), recv.recv());
assert_eq!(Err(RecvError), recv.recv());

pub fn recv_timeout(&self, timeout: Duration) -> Result<T, RecvTimeoutError>

尝试等待此接收器上的值，如果相应的通道已挂起，或者等待的时间超过 timeout，则返回错误。

如果没有可用数据并且有可能发送更多数据 (至少一个发送者仍然存在)，此函数将始终阻塞当前线程。 一旦消息发送到相应的 Sender (或 SyncSender)，该接收者将唤醒并返回该消息。

如果相应的 Sender 断开连接，或者在此调用阻塞时断开连接，则此调用将唤醒并返回 Err，以指示该通道上再也不会收到任何消息。

但是，由于缓冲了通道，因此在断开连接之前发送的消息仍将被正确接收。

已知的问题

当前存在一个已知问题 (请参见 #39364)，以下示例导致 recv_timeout 意外变为 panic:

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

let (tx, rx) = channel::<String>();

thread::spawn(move || {
    let d = Duration::from_millis(10);
    loop {
        println!("recv");
        let _r = rx.recv_timeout(d);
    }
});

thread::sleep(Duration::from_millis(100));
let _c1 = tx.clone();

thread::sleep(Duration::from_secs(1));

Examples

在遇到超时之前成功获得值:

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

let (send, recv) = mpsc::channel();

thread::spawn(move || {
    send.send('a').unwrap();
});

assert_eq!(
    recv.recv_timeout(Duration::from_millis(400)),
    Ok('a')
);

到达超时时收到错误:

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

let (send, recv) = mpsc::channel();

thread::spawn(move || {
    thread::sleep(Duration::from_millis(800));
    send.send('a').unwrap();
});

assert_eq!(
    recv.recv_timeout(Duration::from_millis(400)),
    Err(mpsc::RecvTimeoutError::Timeout)
);

pub fn recv_deadline(&self, deadline: Instant) -> Result<T, RecvTimeoutError>

🔬 This is a nightly-only experimental API. (deadline_api #46316)

尝试等待此接收器上的值，如果相应的通道已挂起，或者到达 deadline，则返回错误。

如果没有可用数据，并且有可能发送更多数据，则此函数将始终阻止当前线程。 将消息发送到相应的 Sender (或 SyncSender) 后，此接收者将唤醒并返回该消息。

如果相应的 Sender 断开连接，或者在此调用阻塞时断开连接，则此调用将唤醒并返回 Err，以指示该通道上再也不会收到任何消息。

但是，由于缓冲了通道，因此在断开连接之前发送的消息仍将被正确接收。

Examples

在截止日期之前成功获得值:

#![feature(deadline_api)]
use std::thread;
use std::time::{Duration, Instant};
use std::sync::mpsc;

let (send, recv) = mpsc::channel();

thread::spawn(move || {
    send.send('a').unwrap();
});

assert_eq!(
    recv.recv_deadline(Instant::now() + Duration::from_millis(400)),
    Ok('a')
);

在截止日期前收到错误:

#![feature(deadline_api)]
use std::thread;
use std::time::{Duration, Instant};
use std::sync::mpsc;

let (send, recv) = mpsc::channel();

thread::spawn(move || {
    thread::sleep(Duration::from_millis(800));
    send.send('a').unwrap();
});

assert_eq!(
    recv.recv_deadline(Instant::now() + Duration::from_millis(400)),
    Err(mpsc::RecvTimeoutError::Timeout)
);

pub fn iter(&self) -> Iter<'_, T>

返回一个迭代器，该迭代器将阻止等待消息，但不会阻止 panic!。 通道挂起时，它将返回 None。

Examples

use std::sync::mpsc::channel;
use std::thread;

let (send, recv) = channel();

thread::spawn(move || {
    send.send(1).unwrap();
    send.send(2).unwrap();
    send.send(3).unwrap();
});

let mut iter = recv.iter();
assert_eq!(iter.next(), Some(1));
assert_eq!(iter.next(), Some(2));
assert_eq!(iter.next(), Some(3));
assert_eq!(iter.next(), None);

pub fn try_iter(&self) -> TryIter<'_, T>

返回一个迭代器，它将尝试产生所有挂起的值。 如果没有其他未决值或通道已挂断，它将返回 None。 迭代器永远不会 panic! 或通过等待值来阻止用户。

Examples

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

let (sender, receiver) = channel();

// 缓冲区中还没有任何东西
assert!(receiver.try_iter().next().is_none());

thread::spawn(move || {
    thread::sleep(Duration::from_secs(1));
    sender.send(1).unwrap();
    sender.send(2).unwrap();
    sender.send(3).unwrap();
});

// 缓冲区中还没有任何东西
assert!(receiver.try_iter().next().is_none());

// 阻塞两秒钟
thread::sleep(Duration::from_secs(2));

let mut iter = receiver.try_iter();
assert_eq!(iter.next(), Some(1));
assert_eq!(iter.next(), Some(2));
assert_eq!(iter.next(), Some(3));
assert_eq!(iter.next(), None);

Trait Implementations

impl<T> Debug for Receiver<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

使用给定的格式化程序格式化该值。

impl<T> Drop for Receiver<T>

fn drop(&mut self)

执行此类型的析构函数。

impl<'a, T> IntoIterator for &'a Receiver<T>

type Item = T

被迭代的元素的类型。

type IntoIter = Iter<'a, T>

我们将其变成哪种迭代器?

fn into_iter(self) -> Iter<'a, T>

从一个值创建一个迭代器。

impl<T> IntoIterator for Receiver<T>

type Item = T

被迭代的元素的类型。

type IntoIter = IntoIter<T>

我们将其变成哪种迭代器?

fn into_iter(self) -> IntoIter<T>

从一个值创建一个迭代器。

impl<T: Send> Send for Receiver<T>

impl<T> !Sync for Receiver<T>