RawMutex 的一字节状态机

const LOCKED_BIT: u8 = 0b01;
const PARKED_BIT: u8 = 0b10;

pub struct RawMutex {
    /// # State table:
    ///
    /// PARKED_BIT | LOCKED_BIT | Description
    ///     0      |     0      | The mutex is not locked, nor is anyone waiting for it.
    ///     0      |     1      | The mutex is locked by exactly one thread. No other thread is
    ///            |            | waiting for it.
    ///     1      |     0      | The mutex is not locked. One or more thread is parked or about to
    ///            |            | park. At least one of the parked threads are just about to be
    ///            |            | unparked, or a thread heading for parking might abort the park.
    ///     1      |     1      | The mutex is locked by exactly one thread. One or more thread is
    ///            |            | parked or about to park, waiting for the lock to become available.
    ///            |            | In this state, PARKED_BIT is only ever cleared when a bucket lock
    ///            |            | is held (i.e. in a parking_lot_core callback). This ensures that
    ///            |            | we never end up in a situation where there are parked threads but
    ///            |            | PARKED_BIT is not set (which would result in those threads
    ///            |            | potentially never getting woken up).
    state: AtomicU8,
}

#[inline]
fn lock(&self) {
    if self
        .state
        .compare_exchange_weak(0, LOCKED_BIT, Ordering::Acquire, Ordering::Relaxed)
        .is_err()
    {
        self.lock_slow(None);
    }
    unsafe { deadlock::acquire_resource(self as *const _ as usize) };
}

#[inline]
unsafe fn unlock(&self) {
    deadlock::release_resource(self as *const _ as usize);
    if self
        .state
        .compare_exchange(LOCKED_BIT, 0, Ordering::Release, Ordering::Relaxed)
        .is_ok()
    {
        return;
    }
    self.unlock_slow(false);
}

#[cold]
fn lock_slow(&self, timeout: Option<Instant>) -> bool {
    let mut spinwait = SpinWait::new();
    let mut state = self.state.load(Ordering::Relaxed);
    loop {
        // 1. Grab the lock if it isn't locked, even if there is a queue on it
        if state & LOCKED_BIT == 0 {
            match self.state.compare_exchange_weak(
                state, state | LOCKED_BIT, Ordering::Acquire, Ordering::Relaxed) {
                Ok(_) => return true,
                Err(x) => state = x,
            }
            continue;
        }
        // 2. If there is no queue, try spinning a few times
        if state & PARKED_BIT == 0 && spinwait.spin() {
            state = self.state.load(Ordering::Relaxed);
            continue;
        }
        // 3. Set the parked bit
        if state & PARKED_BIT == 0 {
            if let Err(x) = self.state.compare_exchange_weak(
                state, state | PARKED_BIT, Ordering::Relaxed, Ordering::Relaxed) {
                state = x;
                continue;
            }
        }
        // 4. Park our thread until we are woken up by an unlock
        let addr = self as *const _ as usize;
        let validate = || self.state.load(Ordering::Relaxed) == LOCKED_BIT | PARKED_BIT;
        let before_sleep = || {};
        let timed_out = |_, was_last_thread| {
            if was_last_thread {
                self.state.fetch_and(!PARKED_BIT, Ordering::Relaxed);
            }
        };
        match unsafe { parking_lot_core::park(addr, validate, before_sleep, timed_out,
                                              DEFAULT_PARK_TOKEN, timeout) } {
            ParkResult::Unparked(TOKEN_HANDOFF) => return true,
            ParkResult::Unparked(_) => (),
            ParkResult::Invalid => (),
            ParkResult::TimedOut => return false,
        }
        spinwait.reset();
        state = self.state.load(Ordering::Relaxed);
    }
}

#[cold]
fn unlock_slow(&self, force_fair: bool) {
    let addr = self as *const _ as usize;
    let callback = |result: UnparkResult| {
        // If we are using a fair unlock then we should keep the
        // mutex locked and hand it off to the unparked thread.
        if result.unparked_threads != 0 && (force_fair || result.be_fair) {
            // Clear the parked bit if there are no more parked threads.
            if !result.have_more_threads {
                self.state.store(LOCKED_BIT, Ordering::Relaxed);
            }
            return TOKEN_HANDOFF;
        }

        // Clear the locked bit, and the parked bit as well if there
        // are no more parked threads.
        if result.have_more_threads {
            self.state.store(PARKED_BIT, Ordering::Release);
        } else {
            self.state.store(0, Ordering::Release);
        }
        TOKEN_NORMAL
    };
    unsafe {
        parking_lot_core::unpark_one(addr, callback);
    }
}