Struct Parker

pub struct Parker { /* private fields */ }

A thread parking primitive.

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

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)

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

Trait Implementations

impl Debug for Parker

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

impl Default for Parker

fn default() -> Self

impl Send for Parker

Auto Trait Implementations

impl !Sync for Parker

impl Freeze for Parker

impl RefUnwindSafe for Parker

impl Unpin for Parker

impl UnsafeUnpin for Parker

impl UnwindSafe for Parker

Blanket Implementations

impl<T> Any for Parker where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Parker where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Parker where T: ?Sized,

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

impl<T> From<T> for Parker

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for Parker where U: From<T>,

fn into(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<U> for Parker where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for Parker where U: TryFrom<T>,

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