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
impl Condvar
impl Condvar
pub async fn wait<T>(&'_ self, guard: MutexGuard<'a, T>) -> MutexGuard<'a, T>
pub async fn wait<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 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<T, F>(
&'_ self,
guard: MutexGuard<'a, T>,
condition: F
) -> MutexGuard<'a, T> where
F: FnMut(&mut T) -> bool,
pub async fn wait_until<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 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<T>(
&'_ self,
guard: MutexGuard<'a, T>,
dur: Duration
) -> (MutexGuard<'a, T>, WaitTimeoutResult)
pub async fn wait_timeout<T>(
&'_ self,
guard: MutexGuard<'a, T>,
dur: Duration
) -> (MutexGuard<'a, T>, WaitTimeoutResult)
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<T, F>(
&'_ self,
guard: MutexGuard<'a, T>,
dur: Duration,
condition: F
) -> (MutexGuard<'a, T>, WaitTimeoutResult) where
F: FnMut(&mut T) -> bool,
pub async fn wait_timeout_until<T, F>(
&'_ self,
guard: MutexGuard<'a, T>,
dur: Duration,
condition: F
) -> (MutexGuard<'a, T>, WaitTimeoutResult) where
F: FnMut(&mut T) -> bool,
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)
pub fn notify_one(&self)
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)
pub fn notify_all(&self)
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
Auto Trait Implementations
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
fn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
sourcefn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
fn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
fn vzip(self) -> V
sourceimpl<T> WithSubscriber for T
impl<T> WithSubscriber for T
sourcefn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
where
S: Into<Dispatch>,
T: Future, type Output = <T as Future>::Output;
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
sourcefn with_current_subscriber(self) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
fn with_current_subscriber(self) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more