#futures #async #data-structures #mutex #lock

qutex

Synchronization mechanisms that rely on lock-free and other non-(thread)blocking techniques, such as Rust futures, to guarantee mutually exclusive or shared exclusive access to data

16 releases

0.2.4 Aug 21, 2022
0.2.3 Apr 19, 2019
0.2.2 Mar 8, 2019
0.2.1 Mar 22, 2018
0.0.5 Mar 26, 2017

#163 in Concurrency

Download history 1315/week @ 2023-10-15 1185/week @ 2023-10-22 1298/week @ 2023-10-29 1229/week @ 2023-11-05 969/week @ 2023-11-12 1146/week @ 2023-11-19 1056/week @ 2023-11-26 997/week @ 2023-12-03 1182/week @ 2023-12-10 1278/week @ 2023-12-17 1160/week @ 2023-12-24 1043/week @ 2023-12-31 1382/week @ 2024-01-07 1223/week @ 2024-01-14 983/week @ 2024-01-21 1279/week @ 2024-01-28

4,958 downloads per month
Used in 48 crates (3 directly)

MIT license

54KB
1K SLoC

Qutex

Non-thread-blocking queue-backed data locks based on Rust futures.

Includes futures capable versions of Mutex and RwLock.

Documentation

Example

Cargo.toml:

[dependencies]
qutex = "0.2"

main.rs:

extern crate qutex;
extern crate futures;

use std::thread;
use futures::Future;
use qutex::Qutex;

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

    for _ in 0..thread_count {
        let future_val = qutex.clone().lock();

        let future_add = future_val.map(|mut val| {
            *val += 1;
        });

        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);
}

Dependencies

~155–315KB