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

pub fn new() -> Parker

Creates a new Parker.

Examples

use crossbeam_utils::sync::Parker;

let p = Parker::new();

pub fn park(&self)

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)

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

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 Debug for Parker

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

Formats the value using the given formatter.

impl Send for Parker