async-priority-lock 0.1.2

A priority-based async lock. Optionally no-std.
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

# async-priority-lock

A priority-based mutex where access is granted by order of priority.

# Example

```rust
use async_priority_lock::{PriorityMutex, PriorityMutexGuard};
use tokio::time::{Duration, sleep};

static MY_LOCK: PriorityMutex<usize, Vec<usize>> = PriorityMutex::new(vec![]);

async fn append(priority: usize, value: usize) {
    // lock at priority zero
    loop {
        let mut guard = MY_LOCK.lock(priority).await;

        tokio::select! {
            // Abort and retry on evict.  Note that eviction is voluntary and isn't
            // enabled unless the `evict` flag is set.  If this example didn't handle,
            // evict the result would have a non-deterministic start (whichever got the lock first)
            // with subsequent entries pushing to the list according to their priority
            _ = PriorityMutexGuard::evicted(&mut guard) => { continue },
            // Make sure this future is cancel-safe if running in a loop like this
            _ = sleep(Duration::from_millis(10)) => {
                guard.push(value);
                break;
            }
        }
    }
}

#[tokio::main]
async fn main() {
    tokio::join!(append(0, 1), append(3, 3), append(2, 2));
    println!("data: {:?}", MY_LOCK); // data: PriorityMutex([3, 2, 1])
}
```


# Features
- `evict` - enables eviction of current lock holders `PriorityMutexGuard::evicted`
- `no-std` - allows compiling for `no_std` (note: `alloc` still required)
- `serde` - allows serde to deserialize into mutexes (but not serialize)