waitx 0.1.1

Lightweight synchronization primitive for one-time ready/wait signaling with optional notification.
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

# waitx


**waitx** is a minimal synchronization utility for signaling readiness between threads using a lightweight flag, a condition variable, and optional backoff. It provides a flexible alternative to channels or more heavyweight synchronization primitives when you just need to wait for a single "ready" event.

## Features


- **Waiter**: blocks until a flag is set, using backoff + condition variable.
- **Notifier**: sets the flag and notifies a waiting thread.
- **Setter**: sets the flag without notifying.
- **Spectator**: reads the state without modifying it.
- Lightweight and `no_std`-compatible (with `alloc`).
- Built on `parking_lot` and `crossbeam-utils`.

## Usage


Add to your `Cargo.toml`:

```toml
[dependencies]
waitx = "0.1"
```

## Example

```rust
use std::thread;
use waitx::Waiter;

let waiter = Waiter::default();
let notifier = waiter.notifier();

let handle = thread::spawn(move || {
    println!("Worker waiting...");
    waiter.wait();
    println!("Worker resumed!");
});

std::thread::sleep(std::time::Duration::from_millis(100));
notifier.notify();
handle.join().unwrap();
```

## When to Use

- Use waitx when you want a simple signaling mechanism:
- One thread signals readiness, another waits.
- A flag is reused multiple times with resets.
- You want fine control over notification vs. just setting state.

## Crate Goals

- Minimal API
- Efficient signaling
- No channels or locks unless needed
- Readable and ergonomic code