logo
pub struct Condvar { /* private fields */ }
Expand description

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

Creates a new condition variable

Examples
use async_std::sync::Condvar;

let cvar = Condvar::new();

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

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;

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

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

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

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

Formats the value using the given formatter. Read more

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

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

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

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.