Struct qutex::Qutex

pub struct Qutex<T> { /* private fields */ }

A lock-free-queue-backed exclusive data lock.

Implementations

impl<T> Qutex<T>

pub fn new(val: T) -> Qutex<T>

Creates and returns a new Qutex.

Examples found in repository

examples/qutex.rs (line 14)

fn main() {
    let thread_count = 100;
    let mut threads = Vec::with_capacity(thread_count);
    let start_val = 0;

    // Create a `Qutex` protecting a start value of zero.
    let qutex = Qutex::new(start_val);

    // Spawn several threads, each adding 1 to the protected value.
    for _ in 0..thread_count {
        // Obtain a 'guard' (akin to a `std::sync::MutexGuard`).
        let future_val = qutex.clone().lock();

        // Add 1 to the protected value. `future_val` is a `FutureGuard` which
        // will resolve to a `Guard` providing mutable access to the protected
        // value. The guard can be passed between futures combinators and will
        // unlock the `Qutex` when dropped.
        let future_add = future_val.map(|mut val| {
            *val += 1;
        });

        // Spawn a thread which blocks upon completion of the above lock and
        // add operations.
        threads.push(thread::spawn(|| {
            future_add.wait().unwrap();
        }));
    }

    for thread in threads {
        thread.join().unwrap();
    }

    let val = qutex.lock().wait().unwrap();
    assert_eq!(*val, start_val + thread_count);
    println!("Qutex final value: {}", *val);
}

pub fn lock(self) -> FutureGuard<T>

Returns a new FutureGuard which can be used as a future and will resolve into a Guard.

Examples found in repository

examples/qutex.rs (line 19)

fn main() {
    let thread_count = 100;
    let mut threads = Vec::with_capacity(thread_count);
    let start_val = 0;

    // Create a `Qutex` protecting a start value of zero.
    let qutex = Qutex::new(start_val);

    // Spawn several threads, each adding 1 to the protected value.
    for _ in 0..thread_count {
        // Obtain a 'guard' (akin to a `std::sync::MutexGuard`).
        let future_val = qutex.clone().lock();

        // Add 1 to the protected value. `future_val` is a `FutureGuard` which
        // will resolve to a `Guard` providing mutable access to the protected
        // value. The guard can be passed between futures combinators and will
        // unlock the `Qutex` when dropped.
        let future_add = future_val.map(|mut val| {
            *val += 1;
        });

        // Spawn a thread which blocks upon completion of the above lock and
        // add operations.
        threads.push(thread::spawn(|| {
            future_add.wait().unwrap();
        }));
    }

    for thread in threads {
        thread.join().unwrap();
    }

    let val = qutex.lock().wait().unwrap();
    assert_eq!(*val, start_val + thread_count);
    println!("Qutex final value: {}", *val);
}

pub unsafe fn push_request(&self, req: Request)

Pushes a lock request onto the queue.

pub fn get_mut(&mut self) -> Option<&mut T>

Returns a mutable reference to the inner Vec if there are currently no other copies of this Qutex.

Since this call borrows the inner lock mutably, no actual locking needs to take place—the mutable borrow statically guarantees no locks exist.

pub fn as_ptr(&self) -> *const T

Returns a reference to the inner value.

pub fn as_mut_ptr(&self) -> *mut T

Returns a mutable reference to the inner value.

pub unsafe fn process_queue(&self)

Pops the next lock request in the queue if this (the caller’s) lock is unlocked.

pub unsafe fn direct_unlock(&self)

Unlocks this (the caller’s) lock and wakes up the next task in the queue.

Trait Implementations

impl<T> Clone for Qutex<T>

fn clone(&self) -> Qutex<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Qutex<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default> Default for Qutex<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> From<T> for Qutex<T>

fn from(val: T) -> Qutex<T>

Converts to this type from the input type.