mpdn/try-mutex

A non-blocking mutual exclusion primitive

A simple non-blocking mutex (i.e. only try_lock is supported), using atomics.

Simpler than the one found in stdlib. Does not support poisoning.

This used to be faster than the mutex in the standard library, but benchmarking indicates that optimizations in the standard library means there is no longer a significant difference (on my machine). Be sure to run them on your own machine to compare.

Nevertheless, this library may still be useful for embedded or similar cases.

try-mutex's Issues

TryMutex<T> should have Send bound on T

Hi there, we (Rust group @sslab-gatech) are scanning crates on crates.io for potential soundness bugs. We noticed that TryMutex implements Sync for all types T:

try-mutex/src/lib.rs

Line 127 in 9775aef

unsafe impl<T> Sync for TryMutex<T> {}

This should probably be bounded by T: Send just like the standard library's Mutex, otherwise it allows smuggling non-Send types like Rc across thread-boundaries like so:

#![forbid(unsafe_code)]

use try_mutex::TryMutex;

use std::rc::Rc;
use crossbeam_utils::thread;

fn main() {
    let rc = Rc::new(());
    let rc_clone = rc.clone();

    let try_mutex = TryMutex::new(rc_clone);
    thread::scope(|s| {    
        s.spawn(|_| {
            let smuggled_rc = try_mutex.try_lock().unwrap();
            println!("RC in thread: {:p}", *smuggled_rc);
        });
    });
    println!("RC in main:   {:p}", rc);
}

This outputs:

RC in thread: 0x5642ef5ffa50
RC in main:   0x5642ef5ffa50

and can lead to data races from safe Rust code.