rufutex 0.4.0

Ulrich Drepper's mutex using futex implementation in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

use rufutex::rufutex::SharedFutex;
use rushm::posixaccessor::POSIXShm;
use std::thread;

fn wait_locked() {
    let mut shm = POSIXShm::<i32>::new("test_shared_lock_unlock".to_string(), 8);
    unsafe {
        let ret = shm.open();
        assert!(ret.is_ok());
    }
    let ptr_shm = shm.get_cptr_mut();
    let mut shared_futex = SharedFutex::new(ptr_shm);
    println!("Thread id {:?} waiting for lock", thread::current().id());
    shared_futex.lock();
    println!("Thread id {:?} got the lock", thread::current().id());
    shared_futex.unlock(1);
}
fn main() {
    // Your code here
    let mut shm = POSIXShm::<i32>::new("test_shared_lock_unlock".to_string(), 8);
    unsafe {
        let ret = shm.open();
        assert!(ret.is_ok());
    }
    let ptr_shm = shm.get_cptr_mut();
    let mut shared_futex = SharedFutex::new(ptr_shm);

    shared_futex.lock();

    let handles: Vec<_> = (0..2)
        .map(|_| {
            thread::spawn(|| {
                wait_locked();
            })
        })
        .collect();

    println!("Main Thread waiting to spawn the threads");
    // Wait some time to spawn the threads
    thread::sleep(std::time::Duration::from_secs(5));
    println!("Main Thread id {:?} unlocking", thread::current().id());
    shared_futex.unlock(1);

    shared_futex.lock();
    shared_futex.unlock(1);

    // Cleanup
    for handle in handles {
        handle.join().unwrap();
    }

    unsafe {
        let ret = shm.close(true);
        assert!(ret.is_ok());
    }
}