Crate spin

source ·
Expand description

This crate provides spin-based versions of the primitives in std::sync and std::lazy. Because synchronization is done through spinning, the primitives are suitable for use in no_std environments.


  • Mutex, RwLock, Once/SyncOnceCell, and SyncLazy equivalents

  • Support for no_std environments

  • lock_api compatibility

  • Upgradeable RwLock guards

  • Guards can be sent and shared between threads

  • Guard leaking

  • Ticket locks

  • Different strategies for dealing with contention

§Relationship with std::sync

While spin is not a drop-in replacement for std::sync (and should not be considered as such) an effort is made to keep this crate reasonably consistent with std::sync.

Many of the types defined in this crate have ‘additional capabilities’ when compared to std::sync:

  • Because spinning does not depend on the thread-driven model of std::sync, guards ([MutexGuard], [RwLockReadGuard], [RwLockWriteGuard], etc.) may be sent and shared between threads.

  • [RwLockUpgradableGuard] supports being upgraded into a [RwLockWriteGuard].

  • Guards support leaking.

  • Once owns the value returned by its call_once initializer.

  • [RwLock] supports counting readers and writers.

Conversely, the types in this crate do not have some of the features std::sync has:

§Feature flags

The crate comes with a few feature flags that you may wish to use.

  • lock_api enables support for lock_api

  • ticket_mutex uses a ticket lock for the implementation of Mutex

  • fair_mutex enables a fairer implementation of Mutex that uses eventual fairness to avoid starvation

  • std enables support for thread yielding instead of spinning



  • Synchronization primitives for one-time evaluation.
  • Strategies that determine the behaviour of locks when encountering contention.

Type Aliases§

  • A primitive that provides lazy one-time initialization. See once::Once for documentation.