Struct async_std::sync::Condvar

pub struct Condvar { /* fields omitted */ }

A Condition Variable

This type is an async version of std::sync::Condvar.

Examples

use std::sync::Arc;

use async_std::sync::{Mutex, Condvar};
use async_std::task;

let pair = Arc::new((Mutex::new(false), Condvar::new()));
let pair2 = pair.clone();

// Inside of our lock, spawn a new thread, and then wait for it to start.
task::spawn(async move {
    let (lock, cvar) = &*pair2;
    let mut started = lock.lock().await;
    *started = true;
    // We notify the condvar that the value has changed.
    cvar.notify_one();
});

// Wait for the thread to start up.
let (lock, cvar) = &*pair;
let mut started = lock.lock().await;
while !*started {
    started = cvar.wait(started).await;
}

Implementations

impl Condvar

pub fn new() -> Self

This is supported on unstable only.

Creates a new condition variable

Examples

use async_std::sync::Condvar;

let cvar = Condvar::new();

pub async fn wait<'a, T>(&self, guard: MutexGuard<'a, T>) -> MutexGuard<'a, T>

This is supported on unstable only.

Blocks the current task until this condition variable receives a notification.

Unlike the std equivalent, this does not check that a single mutex is used at runtime. However, as a best practice avoid using with multiple mutexes.

Examples

use std::sync::Arc;

use async_std::sync::{Mutex, Condvar};
use async_std::task;

let pair = Arc::new((Mutex::new(false), Condvar::new()));
let pair2 = pair.clone();

task::spawn(async move {
    let (lock, cvar) = &*pair2;
    let mut started = lock.lock().await;
    *started = true;
    // We notify the condvar that the value has changed.
    cvar.notify_one();
});

// Wait for the thread to start up.
let (lock, cvar) = &*pair;
let mut started = lock.lock().await;
while !*started {
    started = cvar.wait(started).await;
}

pub async fn wait_until<'a, T, F>(
    &self,
    guard: MutexGuard<'a, T>,
    condition: F
) -> MutexGuard<'a, T> where
    F: FnMut(&mut T) -> bool, 

This is supported on unstable only.

Blocks the current taks until this condition variable receives a notification and the required condition is met. Spurious wakeups are ignored and this function will only return once the condition has been met.

Examples

use std::sync::Arc;

use async_std::sync::{Mutex, Condvar};
use async_std::task;

let pair = Arc::new((Mutex::new(false), Condvar::new()));
let pair2 = pair.clone();

task::spawn(async move {
    let (lock, cvar) = &*pair2;
    let mut started = lock.lock().await;
    *started = true;
    // We notify the condvar that the value has changed.
    cvar.notify_one();
});

// Wait for the thread to start up.
let (lock, cvar) = &*pair;
// As long as the value inside the `Mutex<bool>` is `false`, we wait.
let _guard = cvar.wait_until(lock.lock().await, |started| { *started }).await;

pub async fn wait_timeout<'a, T>(
    &self,
    guard: MutexGuard<'a, T>,
    dur: Duration
) -> (MutexGuard<'a, T>, WaitTimeoutResult)

This is supported on unstable only.

Waits on this condition variable for a notification, timing out after a specified duration.

For these reasons Condvar::wait_timeout_until is recommended in most cases.

Examples

use std::sync::Arc;
use std::time::Duration;

use async_std::sync::{Mutex, Condvar};
use async_std::task;

let pair = Arc::new((Mutex::new(false), Condvar::new()));
let pair2 = pair.clone();

task::spawn(async move {
  let (lock, cvar) = &*pair2;
  let mut started = lock.lock().await;
  *started = true;
  // We notify the condvar that the value has changed.
  cvar.notify_one();
});

// wait for the thread to start up
let (lock, cvar) = &*pair;
let mut started = lock.lock().await;
loop {
  let result = cvar.wait_timeout(started, Duration::from_millis(10)).await;
  started = result.0;
  if *started == true {
      // We received the notification and the value has been updated, we can leave.
      break
  }
}

pub async fn wait_timeout_until<'a, T, F>(
    &self,
    guard: MutexGuard<'a, T>,
    dur: Duration,
    condition: F
) -> (MutexGuard<'a, T>, WaitTimeoutResult) where
    F: FnMut(&mut T) -> bool, 

This is supported on unstable only.

Waits on this condition variable for a notification, timing out after a specified duration. Spurious wakes will not cause this function to return.

Examples

use std::sync::Arc;
use std::time::Duration;

use async_std::sync::{Mutex, Condvar};
use async_std::task;

let pair = Arc::new((Mutex::new(false), Condvar::new()));
let pair2 = pair.clone();

task::spawn(async move {
    let (lock, cvar) = &*pair2;
    let mut started = lock.lock().await;
    *started = true;
    // We notify the condvar that the value has changed.
    cvar.notify_one();
});

// wait for the thread to start up
let (lock, cvar) = &*pair;
let result = cvar.wait_timeout_until(
    lock.lock().await,
    Duration::from_millis(100),
    |&mut started| started,
).await;
if result.1.timed_out() {
    // timed-out without the condition ever evaluating to true.
}
// access the locked mutex via result.0

pub fn notify_one(&self)

This is supported on unstable only.

Wakes up one blocked task on this condvar.

Examples

use std::sync::Arc;

use async_std::sync::{Mutex, Condvar};
use async_std::task;

let pair = Arc::new((Mutex::new(false), Condvar::new()));
let pair2 = pair.clone();

task::spawn(async move {
    let (lock, cvar) = &*pair2;
    let mut started = lock.lock().await;
    *started = true;
    // We notify the condvar that the value has changed.
    cvar.notify_one();
});

// Wait for the thread to start up.
let (lock, cvar) = &*pair;
let mut started = lock.lock().await;
while !*started {
    started = cvar.wait(started).await;
}

pub fn notify_all(&self)

This is supported on unstable only.

Wakes up all blocked tasks on this condvar.

Examples

use std::sync::Arc;

use async_std::sync::{Mutex, Condvar};
use async_std::task;

let pair = Arc::new((Mutex::new(false), Condvar::new()));
let pair2 = pair.clone();

task::spawn(async move {
    let (lock, cvar) = &*pair2;
    let mut started = lock.lock().await;
    *started = true;
    // We notify the condvar that the value has changed.
    cvar.notify_all();
});

// Wait for the thread to start up.
let (lock, cvar) = &*pair;
let mut started = lock.lock().await;
// As long as the value inside the `Mutex<bool>` is `false`, we wait.
while !*started {
    started = cvar.wait(started).await;
}

Trait Implementations

impl Debug for Condvar

This is supported on unstable only.

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

Formats the value using the given formatter.

impl Default for Condvar

This is supported on unstable only.

fn default() -> Self

Returns the “default value” for a type.

impl Send for Condvar

This is supported on unstable only.

impl Sync for Condvar

This is supported on unstable only.