How to implement a lock-free data structure

Concurrency
2026-04-17T12:05:42+00:00
Use Rust's atomic types and compare-exchange operations to build lock-free data structures that safely handle concurrent access without blocking threads.

Implement a lock-free data structure in Rust by using atomic types from std::sync::atomic and atomic operations like compare_exchange to manage state without locks.

use std::sync::atomic::{AtomicUsize, Ordering};

struct Counter {
    value: AtomicUsize,
}

impl Counter {
    fn new() -> Self {
        Counter { value: AtomicUsize::new(0) }
    }

    fn increment(&self) {
        let mut current = self.value.load(Ordering::Relaxed);
        loop {
            let next = current + 1;
            match self.value.compare_exchange_weak(current, next, Ordering::SeqCst, Ordering::Relaxed) {
                Ok(_) => return,
                Err(v) => current = v,
            }
        }
    }
}

This example uses AtomicUsize and compare_exchange_weak to safely increment a counter across threads without mutexes.