[][src]Struct crossbeam_utils::sync::Parker

pub struct Parker { /* fields omitted */ }

A thread parking primitive.

Conceptually, each Parker has an associated token which is initially not present:

  • The park method blocks the current thread unless or until the token is available, at which point it automatically consumes the token. It may also return spuriously, without consuming the token.

  • The park_timeout method works the same as park, but blocks for a specified maximum time.

  • The unpark method atomically makes the token available if it wasn't already. Because the token is initially absent, unpark followed by park will result in the second call returning immediately.

In other words, each Parker acts a bit like a spinlock that can be locked and unlocked using park and unpark.

Examples

use std::thread;
use std::time::Duration;
use crossbeam_utils::sync::Parker;

let mut p = Parker::new();
let u = p.unparker().clone();

// Make the token available.
u.unpark();
// Wakes up immediately and consumes the token.
p.park();

thread::spawn(move || {
    thread::sleep(Duration::from_millis(500));
    u.unpark();
});

// Wakes up when `u.unpark()` provides the token, but may also wake up
// spuriously before that without consuming the token.
p.park();

Methods

impl Parker[src]

pub fn new() -> Parker[src]

Creates a new Parker.

Examples

use crossbeam_utils::sync::Parker;

let p = Parker::new();

pub fn park(&self)[src]

Blocks the current thread until the token is made available.

A call to park may wake up spuriously without consuming the token, and callers should be prepared for this possibility.

Examples

use crossbeam_utils::sync::Parker;

let mut p = Parker::new();
let u = p.unparker().clone();

// Make the token available.
u.unpark();

// Wakes up immediately and consumes the token.
p.park();

pub fn park_timeout(&self, timeout: Duration)[src]

Blocks the current thread until the token is made available, but only for a limited time.

A call to park_timeout may wake up spuriously without consuming the token, and callers should be prepared for this possibility.

Examples

use std::time::Duration;
use crossbeam_utils::sync::Parker;

let mut p = Parker::new();

// Waits for the token to become available, but will not wait longer than 500 ms.
p.park_timeout(Duration::from_millis(500));

pub fn unparker(&self) -> &Unparker[src]

Returns a reference to an associated Unparker.

The returned Unparker doesn't have to be used by reference - it can also be cloned.

Examples

use crossbeam_utils::sync::Parker;

let mut p = Parker::new();
let u = p.unparker().clone();

// Make the token available.
u.unpark();
// Wakes up immediately and consumes the token.
p.park();

Trait Implementations

impl Send for Parker[src]

impl Debug for Parker[src]

Auto Trait Implementations

impl !Sync for Parker

impl Unpin for Parker

impl !RefUnwindSafe for Parker

impl !UnwindSafe for Parker

Blanket Implementations

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]