Struct stdout_channel::MockStdout
source · pub struct MockStdout<T>(/* private fields */);
Implementations§
source§impl<T> MockStdout<T>
impl<T> MockStdout<T>
Methods from Deref<Target = Mutex<Vec<T>>>§
sourcepub async fn lock(&self) -> MutexGuard<'_, T>
pub async fn lock(&self) -> MutexGuard<'_, T>
Locks this mutex, causing the current task to yield until the lock has
been acquired. When the lock has been acquired, function returns a
MutexGuard
.
If the mutex is available to be acquired immediately, then this call will typically not yield to the runtime. However, this is not guaranteed under all circumstances.
Cancel safety
This method uses a queue to fairly distribute locks in the order they
were requested. Cancelling a call to lock
makes you lose your place in
the queue.
Examples
use tokio::sync::Mutex;
#[tokio::main]
async fn main() {
let mutex = Mutex::new(1);
let mut n = mutex.lock().await;
*n = 2;
}
sourcepub fn blocking_lock(&self) -> MutexGuard<'_, T>
pub fn blocking_lock(&self) -> MutexGuard<'_, T>
Blockingly locks this Mutex
. When the lock has been acquired, function returns a
MutexGuard
.
This method is intended for use cases where you need to use this mutex in asynchronous code as well as in synchronous code.
Panics
This function panics if called within an asynchronous execution context.
- If you find yourself in an asynchronous execution context and needing
to call some (synchronous) function which performs one of these
blocking_
operations, then consider wrapping that call insidespawn_blocking()
(orblock_in_place()
).
Examples
use std::sync::Arc;
use tokio::sync::Mutex;
#[tokio::main]
async fn main() {
let mutex = Arc::new(Mutex::new(1));
let lock = mutex.lock().await;
let mutex1 = Arc::clone(&mutex);
let blocking_task = tokio::task::spawn_blocking(move || {
// This shall block until the `lock` is released.
let mut n = mutex1.blocking_lock();
*n = 2;
});
assert_eq!(*lock, 1);
// Release the lock.
drop(lock);
// Await the completion of the blocking task.
blocking_task.await.unwrap();
// Assert uncontended.
let n = mutex.try_lock().unwrap();
assert_eq!(*n, 2);
}
sourcepub fn blocking_lock_owned(self: Arc<Mutex<T>>) -> OwnedMutexGuard<T>
pub fn blocking_lock_owned(self: Arc<Mutex<T>>) -> OwnedMutexGuard<T>
Blockingly locks this Mutex
. When the lock has been acquired, function returns an
OwnedMutexGuard
.
This method is identical to Mutex::blocking_lock
, except that the returned
guard references the Mutex
with an Arc
rather than by borrowing
it. Therefore, the Mutex
must be wrapped in an Arc
to call this
method, and the guard will live for the 'static
lifetime, as it keeps
the Mutex
alive by holding an Arc
.
Panics
This function panics if called within an asynchronous execution context.
- If you find yourself in an asynchronous execution context and needing
to call some (synchronous) function which performs one of these
blocking_
operations, then consider wrapping that call insidespawn_blocking()
(orblock_in_place()
).
Examples
use std::sync::Arc;
use tokio::sync::Mutex;
#[tokio::main]
async fn main() {
let mutex = Arc::new(Mutex::new(1));
let lock = mutex.lock().await;
let mutex1 = Arc::clone(&mutex);
let blocking_task = tokio::task::spawn_blocking(move || {
// This shall block until the `lock` is released.
let mut n = mutex1.blocking_lock_owned();
*n = 2;
});
assert_eq!(*lock, 1);
// Release the lock.
drop(lock);
// Await the completion of the blocking task.
blocking_task.await.unwrap();
// Assert uncontended.
let n = mutex.try_lock().unwrap();
assert_eq!(*n, 2);
}
sourcepub async fn lock_owned(self: Arc<Mutex<T>>) -> OwnedMutexGuard<T>
pub async fn lock_owned(self: Arc<Mutex<T>>) -> OwnedMutexGuard<T>
Locks this mutex, causing the current task to yield until the lock has
been acquired. When the lock has been acquired, this returns an
OwnedMutexGuard
.
If the mutex is available to be acquired immediately, then this call will typically not yield to the runtime. However, this is not guaranteed under all circumstances.
This method is identical to Mutex::lock
, except that the returned
guard references the Mutex
with an Arc
rather than by borrowing
it. Therefore, the Mutex
must be wrapped in an Arc
to call this
method, and the guard will live for the 'static
lifetime, as it keeps
the Mutex
alive by holding an Arc
.
Cancel safety
This method uses a queue to fairly distribute locks in the order they
were requested. Cancelling a call to lock_owned
makes you lose your
place in the queue.
Examples
use tokio::sync::Mutex;
use std::sync::Arc;
#[tokio::main]
async fn main() {
let mutex = Arc::new(Mutex::new(1));
let mut n = mutex.clone().lock_owned().await;
*n = 2;
}
sourcepub fn try_lock(&self) -> Result<MutexGuard<'_, T>, TryLockError>
pub fn try_lock(&self) -> Result<MutexGuard<'_, T>, TryLockError>
Attempts to acquire the lock, and returns TryLockError
if the
lock is currently held somewhere else.
Examples
use tokio::sync::Mutex;
let mutex = Mutex::new(1);
let n = mutex.try_lock()?;
assert_eq!(*n, 1);
sourcepub fn try_lock_owned(
self: Arc<Mutex<T>>
) -> Result<OwnedMutexGuard<T>, TryLockError>
pub fn try_lock_owned( self: Arc<Mutex<T>> ) -> Result<OwnedMutexGuard<T>, TryLockError>
Attempts to acquire the lock, and returns TryLockError
if the lock
is currently held somewhere else.
This method is identical to Mutex::try_lock
, except that the
returned guard references the Mutex
with an Arc
rather than by
borrowing it. Therefore, the Mutex
must be wrapped in an Arc
to call
this method, and the guard will live for the 'static
lifetime, as it
keeps the Mutex
alive by holding an Arc
.
Examples
use tokio::sync::Mutex;
use std::sync::Arc;
let mutex = Arc::new(Mutex::new(1));
let n = mutex.clone().try_lock_owned()?;
assert_eq!(*n, 1);
Trait Implementations§
source§impl<T: Clone> Clone for MockStdout<T>
impl<T: Clone> Clone for MockStdout<T>
source§fn clone(&self) -> MockStdout<T>
fn clone(&self) -> MockStdout<T>
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read more