atomic_once_cell 0.2.0

Thread-safe and lock-free OnceCell and Lazy
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
57
58
59
60
61
62
63
64

![Pipeline](https://github.com/rustne-kretser/atomic_once_cell/actions/workflows/rust.yml/badge.svg)
[![Crates.io](https://img.shields.io/crates/v/atomic_once_cell.svg)](https://crates.io/crates/atomic_once_cell)
[![API reference](https://docs.rs/atomic_once_cell/badge.svg)](https://docs.rs/atomic_once_cell/)

# atomic_once_cell

`atomic_once_cell` provides two new types, [`AtomicOnceCell`] and
[`AtomicLazy`], which are thread-safe and mostly lock-free drop-in
replacements of [`core::lazy::OnceCell`] and [`core::lazy::Lazy`]
suitable for use in `#[no_std]` environments.

### Blocking

Because dereferencing [`AtomicLazy`] can't fail, it can't be
lock-free (if you know a way, please tell me).

Both types can be used in a non-blocking way, but there are some
blocking calls that should not be used from interrupt handlers or
other contexts where blocking will lead to a deadlock. Blocking is
based on
[`crossbeam::utils::Backoff`](https://docs.rs/crossbeam/latest/crossbeam/utils/struct.Backoff.html),
and will be reduced to a spinlock in `#[no_std]` environments.

### Examples
#### `AtomicOnceCell`

```rust
use atomic_once_cell::AtomicOnceCell;

static CELL: AtomicOnceCell<String> = AtomicOnceCell::new();

fn main() {
    CELL.set("Hello, World!".to_owned()).unwrap();

    assert_eq!(*CELL.get().unwrap(), "Hello, World!");
}
```

#### `AtomicLazy`

```rust
use atomic_once_cell::AtomicLazy;

static LAZY: AtomicLazy<String> = AtomicLazy::new(|| "Hello, World!".to_owned());

fn main() {
    assert_eq!(*LAZY, "Hello, World!");
}
```

For more details, see [docs](https://docs.rs/atomic_once_cell/).

# Usage

Add this to your Cargo.toml:

```toml
[dependencies]
atomic_once_cell = "0.2.0"
```

# License

MPL-2.0