Struct ThreadOwnedLock 

pub struct ThreadOwnedLock<T: ?Sized, P: ThreadIdProvider> { /* private fields */ }

A mutual exclusion primitive similar to Mutex but it only allows the owning thread to access the data.

Lock ownership can be transferred to another thread if the data implements Send with the rebind function.

Attempting to lock more than one time on the same thread will result in an error.

Implementations

impl<T, P: ThreadIdProvider> ThreadOwnedLock<T, P>

pub fn new(value: T) -> Self

Create a new instance of ThreadOwnedLock and bind it to the current thread.

pub fn rebind(self) -> Self

Transfer ownership of the lock to another thread.

Example

use thread_owned_lock::StdThreadOwnedLock;
let lock = StdThreadOwnedLock::new(10);
std::thread::spawn(move|| {
    let lock = lock.rebind();
    // lock can now be accessed on this thread.
    let guard = lock.lock();
});

impl<T: ?Sized, P: ThreadIdProvider> ThreadOwnedLock<T, P>

pub fn lock(&self) -> ThreadOwnedLockGuard<'_, T, P>

Acquires the mutex, returning an RAII style guard which allows access to the data.

Panics

This call will panic if this method is called from a thread other than the owning thread or if the lock has already been acquired.

pub fn try_lock( &self, ) -> Result<ThreadOwnedLockGuard<'_, T, P>, ThreadOwnedMutexError>

Try to acquire the mutex. If one of the following conditions fails, an error will be returned:

• The thread accessing the lock must be the bound thread.
• The lock can only be acquired on time.

Trait Implementations

impl<T: Default, P: ThreadIdProvider> Default for ThreadOwnedLock<T, P>

fn default() -> Self

Returns the “default value” for a type.

impl<T, P: ThreadIdProvider> From<T> for ThreadOwnedLock<T, P>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: ?Sized + Send, P: ThreadIdProvider> Send for ThreadOwnedLock<T, P>

impl<T: ?Sized + Send, P: ThreadIdProvider> Sync for ThreadOwnedLock<T, P>