Struct Sack 

pub struct Sack<T> { /* private fields */ }

A lock-free sack data structure.

A sack is a concurrent data structure that allows adding items and draining them in a lock-free manner. It is implemented as a singly-linked list where the head is an atomic pointer. This allows multiple producers to add items concurrently without locks.

How it works

The Sack is essentially a LIFO (last-in, first-out) stack. When an item is added, it is pushed to the front of the list. When the sack is drained, the entire list is atomically swapped with an empty list, and the old list is returned as a draining iterator.

This design has the following properties:

• Lock-free: Adding and draining items are lock-free operations, which means they don’t require mutual exclusion. This makes them very fast and scalable.
• Concurrent producers: Multiple threads can add items to the sack concurrently.
• Single consumer: Only one thread can drain the sack at a time. This is enforced by the &self receiver on the drain method.

Example

use sack::Sack;
use std::sync::Arc;
use std::thread;

let sack = Arc::new(Sack::new());

// Spawn a producer thread.
let producer = {
    let sack = Arc::clone(&sack);
    thread::spawn(move || {
        for i in 0..10 {
            sack.add(i);
        }
    })
};

// Wait for the producer to finish.
producer.join().unwrap();

// Drain the sack and collect the items.
let mut items: Vec<_> = sack.drain().collect();
items.sort();

assert_eq!(items, (0..10).collect::<Vec<_>>());

Implementations

impl<T> Sack<T>

pub const fn new() -> Self

Creates a new, empty sack.

pub fn add(&self, item: T)

Adds an item to the sack.

This operation is lock-free and can be called by multiple threads concurrently.

pub fn drain(&self) -> Drain<T>

Drains all items from the sack.

This operation is lock-free and returns a draining iterator over the items in the sack.

pub fn is_empty(&self) -> bool

Checks if the sack is empty.

This operation is lock-free.

Trait Implementations

impl<T> Default for Sack<T>

fn default() -> Self

Returns the “default value” for a type.