Struct `Parker`

struct Parker { ... }

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();
# std::thread::sleep(std::time::Duration::from_millis(500)); // wait for background threads closed: https://github.com/rust-lang/miri/issues/1371

Implementations

`impl Parker`

fn new() -> Parker

Creates a new Parker.

Examples

use crossbeam_utils::sync::Parker;

let p = Parker::new();

fn park(self: &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();

fn park_timeout(self: &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));

fn park_deadline(self: &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);

fn unparker(self: &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();

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);
# let _ = unsafe { Parker::from_raw(raw) };

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

`impl Debug for Parker`

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

`impl Default for Parker`

fn default() -> Self

`impl Freeze for Parker`

`impl RefUnwindSafe for Parker`

`impl Send for Parker`

`impl Sync for Parker`

`impl Unpin for Parker`

`impl UnsafeUnpin for Parker`

`impl UnwindSafe for Parker`

`impl<T> Any for Parker`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Parker`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for Parker`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> From for Parker`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T, U> Into for Parker`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Parker`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for Parker`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>