Building a Lightweight Mutex Using Atomic CAS Operations

use std::sync::atomic::{AtomicBool, Ordering};
use std::cell::UnsafeCell;
 
pub struct Spinlock<T> {
    locked: AtomicBool,
    data: UnsafeCell<T>,
}
 
unsafe impl<T: Send> Sync for Spinlock<T> {}
 
impl<T> Spinlock<T> {
    pub const fn new(value: T) -> Self {
        Self {
            locked: AtomicBool::new(false),
            data: UnsafeCell::new(value),
        }
    }
 
    pub fn lock(&self) -> SpinlockGuard<'_, T> {
        while self.locked.compare_exchange_weak(
            false,
            true,
            Ordering::Acquire,
            Ordering::Relaxed
        ).is_err() {
            std::hint::spin_loop();
        }
        SpinlockGuard { lock: self }
    }
}
 
pub struct SpinlockGuard<'a, T> {
    lock: &'a Spinlock<T>,
}
 
impl<T> std::ops::Deref for SpinlockGuard<'_, T> {
    type Target = T;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.lock.data.get() }
    }
}
 
impl<T> Drop for SpinlockGuard<'_, T> {
    fn drop(&mut self) {
        self.lock.locked.store(false, Ordering::Release);
    }
}