Struct Spin

pub struct Spin<T> {
    lock: AtomicBool,
    value: UnsafeCell<T>,
}

By the use of Spinlocks, it is possible to serialize blocks of code that might run parallel on multiple CPU cores.

Synchronization is implemented using a lock variable. Once a thread enters the critical area, it sets the lock variable (to a non-zero value); when this thread leaves the critical area, it resets the lock variable to zero. When trying to enter an already locked critical area, the trying thread actively waits until the critical area is free again.

Fields

lock: AtomicBool

value: UnsafeCell<T>

Wrap the mutable data inside an unsafe cell, so that the compiler doesn’t optimize it away

Implementations

impl<T> Spin<T>

pub const fn new(value: T) -> Self

Create a new spin lock, protecting value

pub fn lock(&self) -> SpinGuard<'_, T>

Locks the lock and returns the protected data.

The data is wrapped in a guard, that unlocks the lock if it goes out of scope.

pub unsafe fn unlock(&self)

This is automatically called by the guard destructor.

pub unsafe fn raw(&self) -> &mut T

If you really want to access the contents. This is not protected by race conditions!

Trait Implementations

impl<T: Debug> Debug for Spin<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default> Default for Spin<T>

fn default() -> Spin<T>

Returns the “default value” for a type.

impl<T: Send> Send for Spin<T>

impl<T> Sync for Spin<T>