Struct spin::mutex::spin::SpinMutex [−][src]
mutex
and spin_mutex
only.Expand description
A spin lock providing mutually exclusive access to data.
Example
use spin; let lock = spin::mutex::SpinMutex::<_>::new(0); // Modify the data *lock.lock() = 2; // Read the data let answer = *lock.lock(); assert_eq!(answer, 2);
Thread safety example
use spin; use std::sync::{Arc, Barrier}; let thread_count = 1000; let spin_mutex = Arc::new(spin::mutex::SpinMutex::<_>::new(0)); // We use a barrier to ensure the readout happens after all writing let barrier = Arc::new(Barrier::new(thread_count + 1)); for _ in (0..thread_count) { let my_barrier = barrier.clone(); let my_lock = spin_mutex.clone(); std::thread::spawn(move || { let mut guard = my_lock.lock(); *guard += 1; // Release the lock to prevent a deadlock drop(guard); my_barrier.wait(); }); } barrier.wait(); let answer = { *spin_mutex.lock() }; assert_eq!(answer, thread_count);
Implementations
Returns a mutable pointer to the underlying data.
This is mostly meant to be used for applications which require manual unlocking, but where storing both the lock and the pointer to the inner data gets inefficient.
Example
let lock = spin::mutex::SpinMutex::<_>::new(42); unsafe { core::mem::forget(lock.lock()); assert_eq!(lock.as_mut_ptr().read(), 42); lock.as_mut_ptr().write(58); lock.force_unlock(); } assert_eq!(*lock.lock(), 58);
Locks the SpinMutex
and returns a guard that permits access to the inner data.
The returned value may be dereferenced for data access and the lock will be dropped when the guard falls out of scope.
let lock = spin::mutex::SpinMutex::<_>::new(0); { let mut data = lock.lock(); // The lock is now locked and the data can be accessed *data += 1; // The lock is implicitly dropped at the end of the scope }
Returns true
if the lock is currently held.
Safety
This function provides no synchronization guarantees and so its result should be considered ‘out of date’ the instant it is called. Do not use it for synchronization purposes. However, it may be useful as a heuristic.
Try to lock this SpinMutex
, returning a lock guard if successful.
Example
let lock = spin::mutex::SpinMutex::<_>::new(42); let maybe_guard = lock.try_lock(); assert!(maybe_guard.is_some()); // `maybe_guard` is still held, so the second call fails let maybe_guard2 = lock.try_lock(); assert!(maybe_guard2.is_none());
Returns a mutable reference to the underlying data.
Since this call borrows the SpinMutex
mutably, and a mutable reference is guaranteed to be exclusive in
Rust, no actual locking needs to take place – the mutable borrow statically guarantees no locks exist. As
such, this is a ‘zero-cost’ operation.
Example
let mut lock = spin::mutex::SpinMutex::<_>::new(0); *lock.get_mut() = 10; assert_eq!(*lock.lock(), 10);
Trait Implementations
type GuardMarker = GuardSend
type GuardMarker = GuardSend
Marker type which determines whether a lock guard should be Send
. Use
one of the GuardSend
or GuardNoSend
helper types here. Read more
Attempts to acquire this mutex without blocking. Returns true
if the lock was successfully acquired and false
otherwise. Read more
Auto Trait Implementations
impl<T, R = Spin> !RefUnwindSafe for SpinMutex<T, R>
impl<T: ?Sized, R> UnwindSafe for SpinMutex<T, R> where
R: UnwindSafe,
T: UnwindSafe,