Crate thread_owned_lock

Expand description

This crates provides a concurrency primitive similar to Mutex but only allows the currently bound thread to access its contents. Unlike Mutex it does not cause a thread to block if another thread has acquired the lock, but the operation will fail immediately.

The primitive also ensures that the owning thread can only acquire the lock once in order to not break Rust’s aliasing rules.

§Use Case

This concurrency primitive is useful to enforce that only one specific thread can access the data within. Depending on your OS, it may also be faster that a regular Mutex. You can run this crate’s benchmark to check how it fairs on your machine.

§Example

use std::sync::RwLock;
use thread_owned_lock::StdThreadOwnedLock;

struct SharedData {
    main_thread_data: StdThreadOwnedLock<i32>,
    shared_data: RwLock<i32>,
}

let shared_data = std::sync::Arc::new(SharedData {
    main_thread_data: StdThreadOwnedLock::new(20),
    shared_data:RwLock::new(30)
});
{
    let guard = shared_data.main_thread_data.lock();
    // Main thread can now access the contents;
}
let data_cloned = shared_data.clone();
std::thread::spawn(move|| {
    if let Err(e) = data_cloned.main_thread_data.try_lock() {
        // On other threads, accessing the main thread data will fail.
    }
});

§no-std

This crate is compatible with no-std. You just need to provide an implementation of ThreadIdProvider trait for your environment and enable the feature no-std.

use thread_owned_lock::{ThreadIdProvider, ThreadOwnedLock};
struct MYThreadIdProvider{}

impl ThreadIdProvider for MYThreadIdProvider {
    type Id = u32;
    fn current_thread_id() -> Self::Id {
        todo!()
    }
}

type MyThreadOwnedLock<T> = ThreadOwnedLock<T, MYThreadIdProvider>;

Structs§

StdThreadIdProvider
ThreadIdProvider implementation based on std::thread::ThreadId
ThreadOwnedLock
A mutual exclusion primitive similar to Mutex but it only allows the owning thread to access the data.
ThreadOwnedLockGuard
An RAII implementation of a “scoped lock” of a mutex. When this structure is dropped (falls out of scope), the lock will be unlocked.

Enums§

ThreadOwnedMutexError

Traits§

ThreadIdProvider
Trait which abstract what the thread ID is and how it can be obtained.

Type Aliases§

StdThreadOwnedLock