Crossbeam Utils

https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/
Admin
Crossbeam Utils is a Rust crate providing miscellaneous tools for concurrent programming, including...
Tokens:40,030
Snippets:315
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### AtomicCell fetch_min Example (isize)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically setting the minimum value for an isize.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7isize);

assert_eq!(a.fetch_min(2), 7);
assert_eq!(a.load(), 2);
```

--------------------------------

### AtomicCell fetch_min Example (usize)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically setting the minimum value for a usize.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7usize);

assert_eq!(a.fetch_min(2), 7);
assert_eq!(a.load(), 2);
```

--------------------------------

### AtomicCell fetch_max Example (usize)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically setting the maximum value for a usize.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7usize);

assert_eq!(a.fetch_max(9), 7);
assert_eq!(a.load(), 9);
```

--------------------------------

### AtomicCell fetch_max Example (isize)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically setting the maximum value for an isize.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7isize);

assert_eq!(a.fetch_max(9), 7);
assert_eq!(a.load(), 9);
```

--------------------------------

### AtomicCell fetch_and Example (isize)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically applying a bitwise AND operation to an isize.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7isize);

assert_eq!(a.fetch_and(3), 7);
assert_eq!(a.load(), 3);
```

--------------------------------

### AtomicCell fetch_and Example (usize)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically applying a bitwise AND operation to a usize.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7usize);

assert_eq!(a.fetch_and(3), 7);
assert_eq!(a.load(), 3);
```

--------------------------------

### AtomicCell fetch_nand Example (usize)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically applying a bitwise NAND operation to a usize.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7usize);

assert_eq!(a.fetch_nand(3), 7);
assert_eq!(a.load(), !(7 & 3));
```

--------------------------------

### AtomicCell fetch_nand Example (isize)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically applying a bitwise NAND operation to an isize.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7isize);

assert_eq!(a.fetch_nand(3), 7);
assert_eq!(a.load(), !(7 & 3));
```

--------------------------------

### AtomicCell fetch_xor Example (isize)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically applying a bitwise XOR operation to an isize.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7isize);

assert_eq!(a.fetch_xor(2), 7);
assert_eq!(a.load(), 5);
```

--------------------------------

### AtomicCell fetch_xor Example (usize)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically applying a bitwise XOR operation to a usize.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7usize);

assert_eq!(a.fetch_xor(2), 7);
assert_eq!(a.load(), 5);
```

--------------------------------

### AtomicCell fetch_or Example (usize)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically applying a bitwise OR operation to a usize.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7usize);

assert_eq!(a.fetch_or(16), 7);
assert_eq!(a.load(), 23);
```

--------------------------------

### AtomicCell fetch_or Example (isize)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically applying a bitwise OR operation to an isize.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7isize);

assert_eq!(a.fetch_or(16), 7);
assert_eq!(a.load(), 23);
```

--------------------------------

### AtomicCell fetch_min Example (i128)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically setting the minimum value for an i128. Returns the previous value.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7i128);

assert_eq!(a.fetch_min(2), 7);
assert_eq!(a.load(), 2);
```

--------------------------------

### AtomicCell fetch_add Example (usize)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically adding a value to a usize. The addition wraps on overflow.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7usize);

assert_eq!(a.fetch_add(3), 7);
assert_eq!(a.load(), 10);
```

--------------------------------

### Parker Usage Example

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/sync/struct.Parker.html

Demonstrates the basic usage of Parker for thread synchronization. It shows how to park a thread until an unparker provides a token.

```rust
use std::thread;
use std::time::Duration;
use crossbeam_utils::sync::Parker;

let p = Parker::new();
let u = p.unparker().clone();

// Make the token available.
u.unpark();
// Wakes up immediately and consumes the token.
p.park();

thread::spawn(move || {
    thread::sleep(Duration::from_millis(500));
    u.unpark();
});

// Wakes up when `u.unpark()` provides the token.
p.park();
```

--------------------------------

### AtomicCell fetch_sub Example (usize)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically subtracting a value from a usize. The subtraction wraps on overflow.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7usize);

assert_eq!(a.fetch_sub(3), 7);
assert_eq!(a.load(), 4);
```

--------------------------------

### AtomicCell fetch_add Example (isize)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically adding a value to an isize. The addition wraps on overflow.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7isize);

assert_eq!(a.fetch_add(3), 7);
assert_eq!(a.load(), 10);
```

--------------------------------

### AtomicCell fetch_min Example (u128)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically setting the minimum value for a u128. Returns the previous value.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7u128);

assert_eq!(a.fetch_min(2), 7);
assert_eq!(a.load(), 2);
```

--------------------------------

### AtomicCell fetch_and Example (i128)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically applying a bitwise AND operation to an i128 value.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7i128);

assert_eq!(a.fetch_and(3), 7);
assert_eq!(a.load(), 3);
```

--------------------------------

### AtomicCell fetch_sub Example (isize)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically subtracting a value from an isize. The subtraction wraps on overflow.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7isize);

assert_eq!(a.fetch_sub(3), 7);
assert_eq!(a.load(), 4);
```

--------------------------------

### AtomicCell fetch_nand Example (i128)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically applying a bitwise NAND operation to an i128 value.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7i128);

assert_eq!(a.fetch_nand(3), 7);
assert_eq!(a.load(), !(7 & 3));
```

--------------------------------

### AtomicCell fetch_or Example (i128)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically applying a bitwise OR operation to an i128 value.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7i128);

assert_eq!(a.fetch_or(16), 7);
assert_eq!(a.load(), 23);
```

--------------------------------

### AtomicCell fetch_max Example (i128)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically setting the maximum value for an i128. Returns the previous value.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7i128);

assert_eq!(a.fetch_max(2), 7);
assert_eq!(a.load(), 7);
```

--------------------------------

### AtomicCell fetch_and Example (u128)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically applying a bitwise AND operation to a u128 value.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7u128);

assert_eq!(a.fetch_and(3), 7);
assert_eq!(a.load(), 3);
```

--------------------------------

### CachePadded::new Constructor Example

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/struct.CachePadded.html

Shows how to create a new CachePadded instance by wrapping a value. The value will be padded and aligned to the cache line size.

```rust
use crossbeam_utils::CachePadded;

let padded_value = CachePadded::new(1);
```

--------------------------------

### AtomicCell fetch_xor Example (i128)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically applying a bitwise XOR operation to an i128 value.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7i128);

assert_eq!(a.fetch_xor(2), 7);
assert_eq!(a.load(), 5);
```

--------------------------------

### AtomicCell fetch_nand Example (u128)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically applying a bitwise NAND operation to a u128 value.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7u128);

assert_eq!(a.fetch_nand(3), 7);
assert_eq!(a.load(), !(7 & 3));
```

--------------------------------

### AtomicCell fetch_xor Example (u128)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically applying a bitwise XOR operation to a u128 value.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7u128);

assert_eq!(a.fetch_xor(2), 7);
assert_eq!(a.load(), 5);
```

--------------------------------

### AtomicCell fetch_or Example (u128)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically applying a bitwise OR operation to a u128 value.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7u128);

assert_eq!(a.fetch_or(16), 7);
assert_eq!(a.load(), 23);
```

--------------------------------

### AtomicCell fetch_max Example (u128)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically setting the maximum value for a u128. Returns the previous value.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7u128);

assert_eq!(a.fetch_max(2), 7);
assert_eq!(a.load(), 7);
```

--------------------------------

### AtomicCell fetch_add Example (i128)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically incrementing an i128 value. The addition wraps on overflow.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7i128);

assert_eq!(a.fetch_add(3), 7);
assert_eq!(a.load(), 10);
```

--------------------------------

### AtomicCell fetch_sub Example (i128)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically decrementing an i128 value. The subtraction wraps on overflow.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7i128);

assert_eq!(a.fetch_sub(3), 7);
assert_eq!(a.load(), 4);
```

--------------------------------

### Try Write Lock Example

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/sync/struct.ShardedLock.html

Shows how to attempt to acquire a write lock using `try_write`. This method returns an error if the lock cannot be acquired immediately, as demonstrated here after a read lock is already held.

```rust
use crossbeam_utils::sync::ShardedLock;

let lock = ShardedLock::new(1);

let n = lock.read().unwrap();
assert_eq!(*n, 1);

assert!(lock.try_write().is_err());
```

--------------------------------

### AtomicCell fetch_add Example (u128)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically incrementing a u128 value. The addition wraps on overflow.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7u128);

assert_eq!(a.fetch_add(3), 7);
assert_eq!(a.load(), 10);
```

--------------------------------

### Create a new Parker

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/sync/struct.Parker.html

Initializes a new Parker instance. This is the starting point for using the Parker for thread synchronization.

```rust
use crossbeam_utils::sync::Parker;

let p = Parker::new();
```

--------------------------------

### AtomicCell fetch_sub Example (u128)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates atomically decrementing a u128 value. The subtraction wraps on overflow.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7u128);

assert_eq!(a.fetch_sub(3), 7);
assert_eq!(a.load(), 4);
```

--------------------------------

### Read Lock Example with Threading

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/sync/struct.ShardedLock.html

Demonstrates acquiring a read lock on a ShardedLock and spawning a thread to also acquire a read lock. The lock is shared using Arc for thread safety.

```rust
use crossbeam_utils::sync::ShardedLock;
use std::sync::Arc;
use std::thread;

let lock = Arc::new(ShardedLock::new(1));
let c_lock = lock.clone();

let n = lock.read().unwrap();
assert_eq!(*n, 1);

thread::spawn(move || {
    let r = c_lock.read();
    assert!(r.is_ok());
}).join().unwrap();
```

--------------------------------

### Write Lock Example with Try Read

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/sync/struct.ShardedLock.html

Demonstrates acquiring a write lock, modifying the data, and then attempting to acquire a read lock which fails because a write lock is already held. This highlights the exclusive nature of write locks.

```rust
use crossbeam_utils::sync::ShardedLock;

let lock = ShardedLock::new(1);

let mut n = lock.write().unwrap();
*n = 2;

assert!(lock.try_read().is_err());
```

--------------------------------

### Nested Scoped Threads Example

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/thread/index.html

Demonstrates how to spawn nested threads within a scope by utilizing the scope reference passed as an argument to the spawned thread's closure. This allows for recursive or hierarchical thread spawning.

```rust
use crossbeam_utils::thread;

thread::scope(|s| {
    s.spawn(|s| {
        s.spawn(|_| println!("nested thread"));
    });
}).unwrap();
```

--------------------------------

### CachePadded Alignment and Padding Example

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/struct.CachePadded.html

Demonstrates how CachePadded ensures alignment and padding. It asserts that the difference between memory addresses of consecutive CachePadded elements is at least 32 bytes and that addresses are aligned to 32-byte boundaries.

```rust
use crossbeam_utils::CachePadded;

let array = [CachePadded::new(1i8), CachePadded::new(2i8)];
let addr1 = &*array[0] as *const i8 as usize;
let addr2 = &*array[1] as *const i8 as usize;

assert!(addr2 - addr1 >= 32);
assert_eq!(addr1 % 32, 0);
assert_eq!(addr2 % 32, 0);
```

--------------------------------

### Parker::new()

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/sync/struct.Parker.html

Creates a new Parker instance.

```APIDOC
## Parker::new()

### Description
Creates a new `Parker`.

### Method
`new()`

### Endpoint
N/A (Constructor)

### Request Example
```rust
use crossbeam_utils::sync::Parker;

let p = Parker::new();
```

### Response Example
```rust
// Parker instance
```
```

--------------------------------

### Create a new WaitGroup

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/sync/struct.WaitGroup.html

Initializes a new instance of a WaitGroup.

```rust
use crossbeam_utils::sync::WaitGroup;

let wg = WaitGroup::new();
```

--------------------------------

### Get mutable reference to inner data

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/sync/struct.ShardedLock.html

Accesses the underlying data mutably without requiring a lock acquisition.

```rust
use crossbeam_utils::sync::ShardedLock;

let mut lock = ShardedLock::new(0);
*lock.get_mut().unwrap() = 10;
assert_eq!(*lock.read().unwrap(), 10);
```

--------------------------------

### Get an Unparker from Parker

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/sync/struct.Parker.html

Retrieves a reference to an associated Unparker, which can be used to signal the Parker. The Unparker can be cloned for use in other threads.

```rust
use crossbeam_utils::sync::Parker;

let p = Parker::new();
let u = p.unparker().clone();

// Make the token available.
u.unpark();
// Wakes up immediately and consumes the token.
p.park();
```

--------------------------------

### CachePadded::into_inner Example

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/struct.CachePadded.html

Demonstrates retrieving the original value from a CachePadded instance using the `into_inner` method. This consumes the CachePadded struct.

```rust
use crossbeam_utils::CachePadded;

let padded_value = CachePadded::new(7);
let value = padded_value.into_inner();
assert_eq!(value, 7);
```

--------------------------------

### Creating a new Backoff

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/struct.Backoff.html

Initialize a new Backoff instance.

```rust
use crossbeam_utils::Backoff;

let backoff = Backoff::new();
```

--------------------------------

### Get the underlying thread handle

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/thread/struct.ScopedJoinHandle.html

Retrieve a handle to the underlying thread associated with a ScopedJoinHandle. This can be useful for inspecting thread properties like its ID.

```rust
use crossbeam_utils::thread;

thread::scope(|s| {
    let handle = s.spawn(|_| println!("A child thread is running"));
    println!("The child thread ID: {:?}", handle.thread().id());
}).unwrap();
```

--------------------------------

### Fetch Min for i16 with AtomicCell

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates fetching the minimum value for an i16 AtomicCell. The previous value is returned.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7i16);

assert_eq!(a.fetch_min(2), 7);
assert_eq!(a.load(), 2);
```

--------------------------------

### Get Raw Pointer to AtomicCell Data

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Returns a raw pointer to the data stored within the AtomicCell. Use with caution as it bypasses thread-safety guarantees if not handled properly.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(5);

let ptr = a.as_ptr();
```

--------------------------------

### AtomicCell<i32> Operations

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates the fetch_min operation for AtomicCell with i32 values.

```APIDOC
## POST /atomic_cell/i32/fetch_min

### Description
Compares and sets the minimum of the current value and `val`, and returns the previous value.

### Method
POST

### Endpoint
/atomic_cell/i32/fetch_min

### Parameters
#### Request Body
- **val** (i32) - Required - The value to compare with the current value.

### Request Example
```json
{
  "val": 2
}
```

### Response
#### Success Response (200)
- **previous_value** (i32) - The value before the operation.

#### Response Example
```json
{
  "previous_value": 7
}
```
```

--------------------------------

### Spinning in a lock-free loop with verification

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/struct.Backoff.html

Demonstrates using spin() within a loop and verifying the atomic state change.

```rust
use crossbeam_utils::Backoff;
use std::sync::atomic::AtomicUsize;
use std::sync::atomic::Ordering::SeqCst;

fn fetch_mul(a: &AtomicUsize, b: usize) -> usize {
    let backoff = Backoff::new();
    loop {
        let val = a.load(SeqCst);
        if a.compare_exchange(val, val.wrapping_mul(b), SeqCst, SeqCst).is_ok() {
            return val;
        }
        backoff.spin();
    }
}

let a = AtomicUsize::new(7);
assert_eq!(fetch_mul(&a, 8), 7);
assert_eq!(a.load(SeqCst), 56);
```

--------------------------------

### Spawn a scoped thread with default configuration

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/thread/struct.ScopedThreadBuilder.html

Demonstrates basic usage of the builder to spawn a thread within a scope.

```rust
use crossbeam_utils::thread;

thread::scope(|s| {
    s.builder()
        .spawn(|_| println!("Running a child thread"))
        .unwrap();
}).unwrap();
```

--------------------------------

### Standard Threads - Borrowing Stack Variables (Fails)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/thread/index.html

This example demonstrates the issue with standard `std::thread::spawn` when trying to borrow stack variables. The borrow checker will prevent this due to lifetime uncertainties, resulting in an 'E0597' error.

```rust
use std::thread;

let people = vec![
    "Alice".to_string(),
    "Bob".to_string(),
    "Carol".to_string(),
];

let mut threads = Vec::new();

for person in &people {
    threads.push(thread::spawn(move || {
        println!("Hello, {}!", person);
    }));
}

for thread in threads {
    thread.join().unwrap();
}
```

--------------------------------

### Fetch Min for u32 with AtomicCell

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates fetching the minimum value for a u32 AtomicCell. The previous value is returned.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7u32);

assert_eq!(a.fetch_min(2), 7);
assert_eq!(a.load(), 2);
```

--------------------------------

### crossbeam-utils Overview

Source: https://docs.rs/crossbeam-utils

Overview of the core modules and structures provided by the crossbeam-utils crate for concurrent programming.

```APIDOC
## crossbeam-utils Overview

### Description
This crate provides miscellaneous tools for concurrent programming in Rust, categorized into atomics, thread synchronization, and general utilities.

### Modules
- **atomic**: Provides atomic types such as `AtomicCell` and `AtomicConsume`.
- **sync**: Provides thread synchronization primitives like `Parker`, `ShardedLock`, and `WaitGroup`.
- **thread**: Provides utilities for spawning threads that can borrow variables from the stack via `scope`.

### Key Structs
- **Backoff**: Used for exponential backoff in spin loops.
- **CachePadded**: Used for padding and aligning a value to the length of a cache line to prevent false sharing.
```

--------------------------------

### Fetch AND for i32 with AtomicCell

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates applying a bitwise AND operation to an i32 AtomicCell. The previous value is returned.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7i32);

assert_eq!(a.fetch_and(3), 7);
assert_eq!(a.load(), 3);
```

--------------------------------

### AtomicCell<T> Constructors and Conversions

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Details on creating and converting to AtomicCell.

```APIDOC
## POST /api/atomiccell/new

### Description
Creates a new AtomicCell with the given initial value.

### Method
POST

### Endpoint
/api/atomiccell/new

### Parameters
#### Request Body
- **initial_value** (any) - Required - The initial value for the AtomicCell.

### Request Example
```json
{
  "initial_value": 7
}
```

### Response
#### Success Response (200)
- **atomic_cell** (object) - The newly created AtomicCell.

#### Response Example
```json
{
  "atomic_cell": {}
}
```
```

```APIDOC
## POST /api/atomiccell/from

### Description
Converts a value into an AtomicCell.

### Method
POST

### Endpoint
/api/atomiccell/from

### Parameters
#### Request Body
- **value** (any) - Required - The value to convert into an AtomicCell.

### Request Example
```json
{
  "value": "hello"
}
```

### Response
#### Success Response (200)
- **atomic_cell** (object) - The AtomicCell created from the input value.

#### Response Example
```json
{
  "atomic_cell": {}
}
```
```

--------------------------------

### Fetch NAND for i32 with AtomicCell

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates applying a bitwise NAND operation to an i32 AtomicCell. The previous value is returned.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7i32);

assert_eq!(a.fetch_nand(3), 7);
assert_eq!(a.load(), !(7 & 3));
```

--------------------------------

### Basic ShardedLock Usage

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/sync/struct.ShardedLock.html

Demonstrates creating a lock and performing read and write operations.

```rust
use crossbeam_utils::sync::ShardedLock;

let lock = ShardedLock::new(5);

// Any number of read locks can be held at once.
{
    let r1 = lock.read().unwrap();
    let r2 = lock.read().unwrap();
    assert_eq!(*r1, 5);
    assert_eq!(*r2, 5);
} // Read locks are dropped at this point.

// However, only one write lock may be held.
{
    let mut w = lock.write().unwrap();
    *w += 1;
    assert_eq!(*w, 6);
} // Write lock is dropped here.
```

--------------------------------

### Crossbeam Utilities - Utilities

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/index.html

This section outlines general utility types provided by crossbeam-utils, such as exponential backoff mechanisms, cache line padding, and scoped thread spawning.

```APIDOC
## Utilities

### Backoff

For exponential backoff in spin loops.

### CachePadded

For padding and aligning a value to the length of a cache line.

### scope

For spawning threads that borrow local variables from the stack.
```

--------------------------------

### Fetch XOR for i32 with AtomicCell

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates applying a bitwise XOR operation to an i32 AtomicCell. The previous value is returned.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7i32);

assert_eq!(a.fetch_xor(2), 7);
assert_eq!(a.load(), 5);
```

--------------------------------

### Unparker Methods

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/sync/struct.Unparker.html

Methods available on the Unparker struct.

```APIDOC
## impl Unparker

### pub fn unpark(&self)

#### Description
Atomically makes the token available if it is not already. This method will wake up the thread blocked on `park` or `park_timeout`, if there is any.

#### Examples
```rust
use std::thread;
use std::time::Duration;
use crossbeam_utils::sync::Parker;

let p = Parker::new();
let u = p.unparker().clone();

thread::spawn(move || {
    thread::sleep(Duration::from_millis(500));
    u.unpark();
});

// Wakes up when `u.unpark()` provides the token.
p.park();
```
```

```APIDOC
### pub fn into_raw(this: Unparker) -> *const ()

#### Description
Converts an `Unparker` into a raw pointer.

#### Examples
```rust
use crossbeam_utils::sync::{Parker, Unparker};

let p = Parker::new();
let u = p.unparker().clone();
let raw = Unparker::into_raw(u);
```
```

```APIDOC
### pub unsafe fn from_raw(ptr: *const ()) -> Unparker

#### Description
Converts a raw pointer into an `Unparker`.

#### Safety
This method is safe to use only with pointers returned by `Unparker::into_raw`.

#### Examples
```rust
use crossbeam_utils::sync::{Parker, Unparker};

let p = Parker::new();
let u = p.unparker().clone();

let raw = Unparker::into_raw(u);
let u = unsafe { Unparker::from_raw(raw) };
```
```

--------------------------------

### Fetch NAND for u32 with AtomicCell

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates applying a bitwise NAND operation to a u32 AtomicCell. The previous value is returned.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7u32);

assert_eq!(a.fetch_nand(3), 7);
assert_eq!(a.load(), !(7 & 3));
```

--------------------------------

### ScopedThreadBuilder Configuration and Spawning

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/thread/struct.ScopedThreadBuilder.html

This section details how to use ScopedThreadBuilder to configure and spawn new threads within a scope. It includes methods for setting thread names and stack sizes, and the primary `spawn` method.

```APIDOC
## ScopedThreadBuilder

Configures the properties of a new thread.

The two configurable properties are:
  * `name`: Specifies an associated name for the thread.
  * `stack_size`: Specifies the desired stack size for the thread.

The `spawn` method will take ownership of the builder and return an `io::Result` of the thread handle with the given configuration.

### `name(self, name: String) -> ScopedThreadBuilder<'scope, 'env>`

Sets the name for the new thread.

The name must not contain null bytes (`\0`).

#### Example
```rust
use crossbeam_utils::thread;
use std::thread::current;

thread::scope(|s| {
    s.builder()
        .name("my thread".to_string())
        .spawn(|_| assert_eq!(current().name(), Some("my thread")))
        .unwrap();
}).unwrap();
```

### `stack_size(self, size: usize) -> ScopedThreadBuilder<'scope, 'env>`

Sets the size of the stack for the new thread.

The stack size is measured in bytes.

#### Example
```rust
use crossbeam_utils::thread;

thread::scope(|s| {
    s.builder()
        .stack_size(32 * 1024)
        .spawn(|_| println!("Running a child thread"))
        .unwrap();
}).unwrap();
```

### `spawn<F, T>(self, f: F) -> Result<ScopedJoinHandle<'scope, T>>`

Spawns a scoped thread with this configuration.

The scoped thread is passed a reference to this scope as an argument, which can be used for spawning nested threads.

The returned handle can be used to manually join the thread before the scope exits.

#### Errors
Unlike the `Scope::spawn` method, this method yields an `io::Result` to capture any failure to create the thread at the OS level.

#### Panics
Panics if a thread name was set and it contained null bytes.

#### Example
```rust
use crossbeam_utils::thread;

thread::scope(|s| {
    let handle = s.builder()
        .spawn(|_| {
            println!("A child thread is running");
            42
        })
        .unwrap();

    // Join the thread and retrieve its result.
    let res = handle.join().unwrap();
    assert_eq!(res, 42);
}).unwrap();
```
```

--------------------------------

### Fetch XOR for u32 with AtomicCell

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates applying a bitwise XOR operation to a u32 AtomicCell. The previous value is returned.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7u32);

assert_eq!(a.fetch_xor(2), 7);
assert_eq!(a.load(), 5);
```

--------------------------------

### Fetch AND for u32 with AtomicCell

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates applying a bitwise AND operation to a u32 AtomicCell. The previous value is returned.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7u32);

assert_eq!(a.fetch_and(3), 7);
assert_eq!(a.load(), 3);
```

--------------------------------

### Fetch Max for i32 with AtomicCell

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates fetching the maximum value for an i32 AtomicCell. The previous value is returned.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7i32);

assert_eq!(a.fetch_max(9), 7);
assert_eq!(a.load(), 9);
```

--------------------------------

### Parker::park()

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/sync/struct.Parker.html

Blocks the current thread until the token is made available.

```APIDOC
## Parker::park()

### Description
Blocks the current thread until the token is made available.

### Method
`park()`

### Endpoint
N/A

### Request Example
```rust
use crossbeam_utils::sync::Parker;

let p = Parker::new();
let u = p.unparker().clone();

// Make the token available.
u.unpark();

// Wakes up immediately and consumes the token.
p.park();
```

### Response Example
(No explicit return value, thread unblocks)
```

--------------------------------

### Fetch OR for i32 with AtomicCell

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates applying a bitwise OR operation to an i32 AtomicCell. The previous value is returned.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7i32);

assert_eq!(a.fetch_or(16), 7);
assert_eq!(a.load(), 23);
```

--------------------------------

### Spawn a scoped thread

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/thread/struct.Scope.html

Demonstrates spawning a thread within a scope and joining it to retrieve a result.

```rust
use crossbeam_utils::thread;

thread::scope(|s| {
    let handle = s.spawn(|_| {
        println!("A child thread is running");
        42
    });

    // Join the thread and retrieve its result.
    let res = handle.join().unwrap();
    assert_eq!(res, 42);
}).unwrap();
```

--------------------------------

### CloneToUninit Trait Implementation

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/struct.CachePadded.html

Details the nightly-only experimental implementation of the `CloneToUninit` trait for types that implement `Clone`.

```APIDOC
## impl<T> CloneToUninit for T

### Description
Nightly-only experimental implementation of the `CloneToUninit` trait.

### Source
Source

#### unsafe fn clone_to_uninit(&self, dest: *mut u8)

##### Description
Performs copy-assignment from `self` to `dest`.

##### Source
Source
```

--------------------------------

### Create AtomicCell

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Initializes a new AtomicCell with a given value. This is the primary way to create an AtomicCell.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7);
```

--------------------------------

### Crossbeam Utilities - Structs

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/index.html

Detailed descriptions of key structs available in the crossbeam-utils crate, including Backoff and CachePadded.

```APIDOC
## Structs

### Backoff

Performs exponential backoff in spin loops.

### CachePadded

Pads and aligns a value to the length of a cache line.
```

--------------------------------

### Module sync

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/sync/index.html

Provides thread synchronization primitives.

```APIDOC
## Module sync

### Description
Thread synchronization primitives.

### Structs

#### Parker
    A thread parking primitive.

#### ShardedLock
    A sharded reader-writer lock with fast concurrent reads.

#### WaitGroup
    For synchronizing the beginning or end of some computation.

### Related Types

#### ShardedLockReadGuard
    A guard used to release the shared read access of a `ShardedLock` when dropped.

#### ShardedLockWriteGuard
    A guard used to release the exclusive write access of a `ShardedLock` when dropped.

#### Unparker
    Unparks a thread parked by the associated `Parker`.
```

--------------------------------

### AtomicCell Overview

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Provides an overview of the AtomicCell struct and its core functionality.

```APIDOC
## Struct AtomicCell

A thread-safe mutable memory location.
This type is equivalent to `Cell`, except it can also be shared among multiple threads.
Operations on `AtomicCell`s use atomic instructions whenever possible, and synchronize using global locks otherwise. You can call `AtomicCell::<T>::is_lock_free()` to check whether atomic instructions or locks will be used.
Atomic loads use the `Acquire` ordering and atomic stores use the `Release` ordering.
```

--------------------------------

### Crossbeam Utilities - Thread Synchronization

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/index.html

This section covers thread synchronization primitives offered by crossbeam-utils, including primitives for parking threads, sharded locks, and synchronization barriers.

```APIDOC
## Thread Synchronization

### Parker

A thread parking primitive.

### ShardedLock

A sharded reader-writer lock with fast concurrent reads.

### WaitGroup

For synchronizing the beginning or end of some computation.
```

--------------------------------

### WaitGroup::new

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/sync/struct.WaitGroup.html

Creates a new wait group and returns the single reference to it.

```APIDOC
## pub fn new()

### Description
Creates a new wait group and returns the single reference to it.

### Request Example
```rust
use crossbeam_utils::sync::WaitGroup;
let wg = WaitGroup::new();
```
```

--------------------------------

### Fetch Max for i16 with AtomicCell

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates fetching the maximum value for an i16 AtomicCell. The previous value is returned.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7i16);

assert_eq!(a.fetch_max(9), 7);
assert_eq!(a.load(), 9);
```

--------------------------------

### Crossbeam Utilities - Modules

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/index.html

Overview of the modules within the crossbeam-utils crate, categorizing its functionalities into atomic operations, synchronization, and thread management.

```APIDOC
## Modules

### atomic

Atomic types.

### sync

Thread synchronization primitives.

### thread

Threads that can borrow variables from the stack.
```

--------------------------------

### TryFrom Trait

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/sync/struct.Parker.html

Documentation for the `TryFrom` trait, which allows for fallible conversions.

```APIDOC
## impl<T, U> TryFrom<U> for T

### Description
Provides a way to attempt a conversion from type `U` to type `T`, which may fail.

### Type Alias
#### type Error = Infallible

The type returned in the event of a conversion error. Note: This specific `Error` type is for the `TryFrom<U>` implementation where `U` is `Infallible`, meaning the conversion is infallible.

### Method
#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion. Returns `Ok(T)` on success or `Err(E)` on failure, where `E` is the associated `Error` type.
```

--------------------------------

### Fetch Max for u32 with AtomicCell

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates fetching the maximum value for a u32 AtomicCell. The previous value is returned.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7u32);

assert_eq!(a.fetch_max(9), 7);
assert_eq!(a.load(), 9);
```

--------------------------------

### TryFrom and TryInto Trait Implementations

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/struct.CachePadded.html

Details the blanket implementations of the `TryFrom<U>` and `TryInto<U>` traits.

```APIDOC
## impl<T, U> TryFrom<U> for T

### Description
Blanket implementation of the `TryFrom` trait.

### Source
Source

#### type Error = Infallible

##### Description
The type returned in the event of a conversion error.

##### Source
Source

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

##### Description
Performs the conversion.

##### Source
Source

## impl<T, U> TryInto<U> for T

### Description
Blanket implementation of the `TryInto` trait.

### Source
Source

#### type Error = <U as TryFrom<T>>::Error

##### Description
The type returned in the event of a conversion error.

##### Source
Source

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

##### Description
Performs the conversion.

##### Source
Source
```

--------------------------------

### From Trait Implementations

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/struct.CachePadded.html

Details the blanket implementations of the `From<!>` and `From<T>` traits.

```APIDOC
## impl<T> From<!> for T

### Description
Blanket implementation of `From<!>`.

### Source
Source

#### fn from(t: !)

##### Description
Converts to this type from the input type.

##### Source
Source

## impl<T> From<T> for T

### Description
Blanket implementation of `From<T>`.

### Source
Source

#### fn from(t: T)

##### Description
Returns the argument unchanged.

##### Source
Source
```

--------------------------------

### AtomicCell fetch_min (i16)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Compares and sets the minimum of the current value and `val`, and returns the previous value.

```APIDOC
## AtomicCell fetch_min (i16)

### Description
Compares and sets the minimum of the current value and `val`, and returns the previous value.

### Method
Not applicable (method on struct)

### Endpoint
Not applicable

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **previous_value** (i16) - The value before the operation.

#### Response Example
```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7i16);

assert_eq!(a.fetch_min(2), 7);
assert_eq!(a.load(), 2);
```
```

--------------------------------

### Fetch OR for u32 with AtomicCell

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates applying a bitwise OR operation to a u32 AtomicCell. The previous value is returned.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7u32);

assert_eq!(a.fetch_or(16), 7);
assert_eq!(a.load(), 23);
```

--------------------------------

### AtomicCell fetch_min (i8)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Compares and sets the minimum of the current value and `val`, and returns the previous value.

```APIDOC
## AtomicCell fetch_min (i8)

### Description
Compares and sets the minimum of the current value and `val`, and returns the previous value.

### Method
Not applicable (method on struct)

### Endpoint
Not applicable

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **previous_value** (i8) - The value before the operation.

#### Response Example
```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7i8);

assert_eq!(a.fetch_min(2), 7);
assert_eq!(a.load(), 2);
```
```

--------------------------------

### User Authentication API

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/thread/struct.Scope.html

Creates a builder that can configure a thread before spawning. This allows for setting options like stack size or thread name before the thread is actually created.

```APIDOC
## Scope::builder

### Description
Creates a builder that can configure a thread before spawning. This allows for setting options like stack size or thread name before the thread is actually created.

### Method
`pub fn builder<'scope>(&'scope self) -> ScopedThreadBuilder<'scope, 'env>`

### Parameters
None

### Request Example
```rust
use crossbeam_utils::thread;

thread::scope(|s| {
    s.builder()
        .spawn(|_| println!("A child thread is running"))
        .unwrap();
}).unwrap();
```

### Response
#### Success Response (200)
- **ScopedThreadBuilder<'scope, 'env>** - A builder object that can be used to configure and spawn a scoped thread.

#### Response Example
```rust
// The return type is ScopedThreadBuilder<'scope, 'env>
// Example usage is shown in the Request Example.
```
```

--------------------------------

### Fetch Add for i32 with AtomicCell

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Demonstrates incrementing an i32 AtomicCell by a value. The addition wraps on overflow. The previous value is returned.

```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7i32);

assert_eq!(a.fetch_add(3), 7);
assert_eq!(a.load(), 10);
```

--------------------------------

### AtomicCell fetch_min (u16)

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/atomic/struct.AtomicCell.html

Compares and sets the minimum of the current value and `val`, and returns the previous value.

```APIDOC
## AtomicCell fetch_min (u16)

### Description
Compares and sets the minimum of the current value and `val`, and returns the previous value.

### Method
Not applicable (method on struct)

### Endpoint
Not applicable

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **previous_value** (u16) - The value before the operation.

#### Response Example
```rust
use crossbeam_utils::atomic::AtomicCell;

let a = AtomicCell::new(7u16);

assert_eq!(a.fetch_min(2), 7);
assert_eq!(a.load(), 2);
```
```

--------------------------------

### Synchronize threads with WaitGroup

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/sync/struct.WaitGroup.html

Demonstrates spawning multiple threads that each hold a clone of the WaitGroup, blocking the main thread until all work is finished.

```rust
use crossbeam_utils::sync::WaitGroup;
use std::thread;

// Create a new wait group.
let wg = WaitGroup::new();

for _ in 0..4 {
    // Create another reference to the wait group.
    let wg = wg.clone();

    thread::spawn(move || {
        // Do some work.

        // Drop the reference to the wait group.
        drop(wg);
    });
}

// Block until all threads have finished their work.
wg.wait();
```

--------------------------------

### Wait for AtomicBool with Backoff

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/struct.Backoff.html

Demonstrates how to efficiently wait for an AtomicBool to become true using the Backoff struct. It includes a mechanism to park the thread after a long wait and snooze during shorter waits.

```rust
use crossbeam_utils::Backoff;
use std::sync::Arc;
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering::SeqCst;
use std::thread;
use std::time::Duration;

fn blocking_wait(ready: &AtomicBool) {
    let backoff = Backoff::new();
    while !ready.load(SeqCst) {
        if backoff.is_completed() {
            thread::park();
        } else {
            backoff.snooze();
        }
    }
}

let ready = Arc::new(AtomicBool::new(false));
let ready2 = ready.clone();
let waiter = thread::current();

thread::spawn(move || {
    thread::sleep(Duration::from_millis(100));
    ready2.store(true, SeqCst);
    waiter.unpark();
});

assert_eq!(ready.load(SeqCst), false);
blocking_wait(&ready);
assert_eq!(ready.load(SeqCst), true);
```

--------------------------------

### ShardedLock Methods

Source: https://docs.rs/crossbeam-utils/0.8.21/crossbeam_utils/sync/struct.ShardedLock.html

API methods for initializing and interacting with the ShardedLock structure.

```APIDOC
## pub fn new(value: T) -> ShardedLock<T>

### Description
Creates a new sharded reader-writer lock.

### Request Example
let lock = ShardedLock::new(5);

## pub fn read(&self) -> LockResult<ShardedLockReadGuard<'_, T>>

### Description
Locks with shared read access, blocking the current thread until it can be acquired.

## pub fn try_read(&self) -> TryLockResult<ShardedLockReadGuard<'_, T>>

### Description
Attempts to acquire this lock with shared read access. If the access could not be granted at this time, an error is returned.

## pub fn get_mut(&mut self) -> LockResult<&mut T>

### Description
Returns a mutable reference to the underlying data. Since this call borrows the lock mutably, no actual locking needs to take place.

## pub fn is_poisoned(&self) -> bool

### Description
Returns true if the lock is poisoned. A lock gets poisoned when a write operation panics.

## pub fn into_inner(self) -> LockResult<T>

### Description
Consumes this lock, returning the underlying data.
```
Tokens:
Raw