Struct Parker

pub struct Parker { /* private fields */ }

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.

• The park_timeout and park_deadline methods work the same as park, but block 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 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.
p.park();

Implementations

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.

Examples

use crossbeam_utils::sync::Parker;

let 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.

Examples

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

let 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 park_deadline(&self, deadline: Instant)

Blocks the current thread until the token is made available, or until a certain deadline.

Examples

use std::time::{Duration, Instant};
use crossbeam_utils::sync::Parker;

let p = Parker::new();
let deadline = Instant::now() + Duration::from_millis(500);

// Waits for the token to become available, but will not wait longer than 500 ms.
p.park_deadline(deadline);

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 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 into_raw(this: Parker) -> *const ()

Converts a Parker into a raw pointer.

Examples

use crossbeam_utils::sync::Parker;

let p = Parker::new();
let raw = Parker::into_raw(p);

pub unsafe fn from_raw(ptr: *const ()) -> Parker

Converts a raw pointer into a Parker.

Safety

This method is safe to use only with pointers returned by Parker::into_raw.

Examples

use crossbeam_utils::sync::Parker;

let p = Parker::new();
let raw = Parker::into_raw(p);
let p = unsafe { Parker::from_raw(raw) };

Trait Implementations

impl Debug for Parker

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

Formats the value using the given formatter.

impl Default for Parker

fn default() -> Self

Returns the “default value” for a type.

impl Send for Parker

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 8 bytes