rustmax 0.0.11

A collection of useful crates.
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

Concurrency tools to supplement `std::sync`, including fast channels.

- Crate [`::crossbeam`].
- [docs.rs](https://docs.rs/crossbeam)
- [crates.io](https://crates.io/crates/crossbeam)
- [GitHub](https://github.com/crossbeam-rs/crossbeam)

---

`crossbeam` provides a collection of tools for concurrent programming in Rust.
It supplements the standard library's [`std::sync`] and [`std::thread`] modules
with high-performance primitives and convenient abstractions.

The crate's primary features include:
- Fast multi-producer multi-consumer channels via [`crossbeam::channel`]
- Scoped threads that can borrow from the parent scope via [`crossbeam::scope`]
- Lock-free and wait-free data structures
- Utilities like [`Backoff`] for optimizing spin loops
- Epoch-based memory reclamation for concurrent data structures

The [`channel`] module provides bounded and unbounded channels
that are faster than [`std::sync::mpsc`] and support multiple producers
and multiple consumers. Channels can be selected over using the [`select!`] macro,
enabling patterns like waiting on multiple channels or implementing timeouts.

The [`scope`] function allows spawning threads that can safely access
non-`'static` data from the parent thread's stack.
This is more ergonomic than [`std::thread::spawn`],
which requires all data to be `'static` or moved into the thread.

## Examples

Using scoped threads to borrow data from the parent scope:

```rust
use crossbeam;

let values = vec![1, 2, 3, 4];
let mut total = 0;

crossbeam::scope(|scope| {
    scope.spawn(|_| {
        // Can safely borrow from parent scope
        for &val in &values {
            println!("Processing: {}", val);
        }
    });
}).unwrap();

assert_eq!(values, vec![1, 2, 3, 4]);
```

Communicating between threads using channels:

```rust
use crossbeam::channel;
use std::thread;

let (sender, receiver) = channel::unbounded();

thread::spawn(move || {
    for i in 0..5 {
        sender.send(i).unwrap();
    }
});

let mut sum = 0;
for received in receiver {
    sum += received;
}

assert_eq!(sum, 10); // 0 + 1 + 2 + 3 + 4
```

Using bounded channels for backpressure:

```rust
use crossbeam::channel;
use std::thread;

let (sender, receiver) = channel::bounded(2);

thread::spawn(move || {
    for i in 0..5 {
        sender.send(i).unwrap(); // Blocks when buffer is full
    }
});

thread::sleep(std::time::Duration::from_millis(10));

let values: Vec<_> = receiver.iter().collect();
assert_eq!(values, vec![0, 1, 2, 3, 4]);
```

Selecting over multiple channels:

```rust
use crossbeam::channel;
use std::thread;
use std::time::Duration;

let (s1, r1) = channel::unbounded();
let (s2, r2) = channel::unbounded();

thread::spawn(move || {
    s1.send("hello").unwrap();
});

thread::spawn(move || {
    thread::sleep(Duration::from_millis(10));
    s2.send("world").unwrap();
});

crossbeam::select! {
    recv(r1) -> msg => assert_eq!(msg, Ok("hello")),
    recv(r2) -> msg => assert_eq!(msg, Ok("world")),
}
```

[`std::sync`]: crate::std::sync
[`std::thread`]: crate::std::thread
[`std::sync::mpsc`]: crate::std::sync::mpsc
[`std::thread::spawn`]: crate::std::thread::spawn
[`crossbeam::channel`]: crate::crossbeam::channel
[`crossbeam::scope`]: crate::crossbeam::scope
[`channel`]: crate::crossbeam::channel
[`scope`]: crate::crossbeam::scope
[`select!`]: crate::crossbeam::select
[`Backoff`]: crate::crossbeam::utils::Backoff