take_lock 0.1.1

a dead simple lock around Option<Box<T>> thats similar in spirit to OnceLock but adds a bit more flexibility by paying a bit in performance
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

# take_lock


**TakeLock** is a minimal, thread-safe container for passing ownership of a single `Box<T>` between threads.

It provides an atomic, lock-free way to `put`, `take`, or `swap` a value across threads.
This is implemented with a fairly straight forward use of atomics.

## Example


```rust
use take_lock::TakeLock;
use std::thread;

let lock = std::sync::Arc::new(TakeLock::default());

let sender = {
    let lock = lock.clone();
    thread::spawn(move || {
        lock.put(Some(Box::new(123))).unwrap();
    })
};

let receiver = {
    let lock = lock.clone();
    thread::spawn(move || {
        loop {
            if let Some(val) = lock.take() {
                assert_eq!(*val, 123);
                break;
            }
        }
    })
};

sender.join().unwrap();
receiver.join().unwrap();