Struct crossbeam_utils::sync::Parker

source ·
pub struct Parker { /* private fields */ }
Expand description

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§

source§

impl Parker

source

pub fn new() -> Parker

Creates a new Parker.

§Examples
use crossbeam_utils::sync::Parker;

let p = Parker::new();
source

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();
source

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

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

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();
source

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

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§

source§

impl Debug for Parker

source§

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

Formats the value using the given formatter. Read more
source§

impl Default for Parker

source§

fn default() -> Self

Returns the “default value” for a type. Read more
source§

impl Send for Parker

Auto Trait Implementations§

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

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

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

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

source§

fn into(self) -> U

Calls U::from(self).

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

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
source§

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

§

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

The type returned in the event of a conversion error.
source§

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

Performs the conversion.