Struct std::sync::mpsc::Receiver

1.0.0 · source ·

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

Expand description

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 秒后收到

Run

Implementations§

source §

impl<T> Receiver<T>

source

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());

Run

source

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());

Run

缓冲行为：

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());

Run

1.12.0 · source

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

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

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

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

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

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')
);

Run

到达超时时收到错误：

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)
);

Run

source

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')
);

Run

在截止日期前收到错误：

#![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)
);

Run

source

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);

Run

1.15.0 · source

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);