Struct ksched::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 ksched::sync::{Mutex, Condvar};
use ksched::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();
}).unwrap();

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

Creates a new condition variable

Examples

use ksched::sync::Condvar;

let cvar = Condvar::new();

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

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 ksched::sync::{Mutex, Condvar};
use ksched::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 await_notify<'a, T>(&self, guard: MutexGuard<'a, T>)

Wait for a notification and release the lock.

pub async fn spin_wait<'a, 'b, T>(
    &'a self,
    guard: SpinlockGuard<'b, T>
) -> SpinlockGuard<'b, T>

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

If failed, return the guard. It is guaranteed that the lock is still held.

Examples

use std::sync::Arc;

use ksched::sync::{Spinlock, Condvar};
use ksched::task;

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

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

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

pub async fn spin_await_notify<'a, 'b, T>(&'a self, guard: SpinlockGuard<'b, T>)

Wait for a notification and release the lock.

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

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 ksched::sync::{Mutex, Condvar};
use ksched::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();
}).unwrap();

// 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 spin_wait_until<'a, 'b, T, F>(
    &'a self,
    guard: SpinlockGuard<'b, T>,
    condition: F
) -> SpinlockGuard<'b, T> where
    F: FnMut(&mut T) -> bool, 

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 ksched::sync::{Spinlock, Condvar};
use ksched::task;

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

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

// 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.spin_wait_until(
    lock.lock(),
    |started| { *started }
).await;

pub fn notify_one(&self)

Wakes up one blocked task on this condvar.

Examples

use std::sync::Arc;

use ksched::sync::{Mutex, Condvar};
use ksched::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();
}).unwrap();

// 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)

Wakes up all blocked tasks on this condvar.

Examples

use std::sync::Arc;

use ksched::sync::{Mutex, Condvar};
use ksched::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

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

Formats the value using the given formatter.

impl Default for Condvar

fn default() -> Self

Returns the “default value” for a type.