#spin #lock #sync #mutex #spin-lock


Synchronization primitives using spinlock. The interface resembles std::sync. The constructors of public structs are const; i.e. it is possible to declare static Mutex<T> as long as T can be build statically.

9 unstable releases (3 breaking)

0.3.2 Feb 5, 2021
0.3.1 Feb 3, 2021
0.3.0 Jan 22, 2021
0.2.1 Sep 4, 2020
0.0.1 Nov 13, 2019

#358 in Concurrency

33 downloads per month

LGPL-3.0-or-later OR Apache-2…

968 lines

Build Status Build Status


CircleCI Build Status

spin-sync is a module providing synchronization primitives using spinlock. (Wikipedia Spinlock)

The main features are as follows.

  • Declaring public structs Mutex , RwLock , Once , Barrier . The interfaces are resembles those of std::sync .
  • Ensuring safety as much as std::sync , including poisoning strategy and marker traits.
  • Declaring public struct Mutex8 , which behaves like a set of 8 Mutex instances except for it gives up poison strategy. It is possible to acquire 2 or more than 2 locks of 1 Mutex8 instance at once.
  • Unlike to std::sync, the constructors of the public structs are const. For example, it is possible to declare static Mutex<T> as long as T can be build statically.


Declare static spin_sync::Mutex<u64> variable and update from multi threads. It is impossible in case of std::sync::Mutex .

extern crate spin_sync;

use spin_sync::Mutex;
use std::thread;

// Declare static mut Mutex<u64> variable.
static COUNT: Mutex<u64> = Mutex::new(0);

fn main() {
    let num_thread = 10;
    let mut handles = Vec::new();

    // Create worker threads to inclement COUNT by 1.
    for _ in 0..10 {
        let handle = thread::spawn(move || {
            let mut count = COUNT.lock().unwrap();
            *count += 1;


    // Wait for all the workers.
    for handle in handles {

    // Make sure the value is incremented by the worker count.
    let count = COUNT.lock().unwrap();
    assert_eq!(num_thread, *count);

License: LGPL-3.0-or-later OR Apache-2.0 OR BSD-2-Clause

No runtime deps