一个 usize 的状态机

/// The task is currently being run.
const RUNNING: usize = 0b0001;

/// The task is complete.
///
/// Once this bit is set, it is never unset.
const COMPLETE: usize = 0b0010;

/// Extracts the task's lifecycle value from the state.
const LIFECYCLE_MASK: usize = 0b11;

/// Flag tracking if the task has been pushed into a run queue.
const NOTIFIED: usize = 0b100;

/// The join handle is still around.
const JOIN_INTEREST: usize = 0b1_000;

/// A join handle waker has been set.
const JOIN_WAKER: usize = 0b10_000;

/// The task has been forcibly cancelled.
const CANCELLED: usize = 0b100_000;

/// All bits.
const STATE_MASK: usize = LIFECYCLE_MASK | NOTIFIED | JOIN_INTEREST | JOIN_WAKER | CANCELLED;

/// Bits used by the ref count portion of the state.
const REF_COUNT_MASK: usize = !STATE_MASK;

/// Number of positions to shift the ref count.
const REF_COUNT_SHIFT: usize = REF_COUNT_MASK.count_zeros() as usize;

/// One ref count.
const REF_ONE: usize = 1 << REF_COUNT_SHIFT;

const INITIAL_STATE: usize = (REF_ONE * 3) | JOIN_INTEREST | NOTIFIED;

fn fetch_update_action<F, T>(&self, mut f: F) -> T
where
    F: FnMut(Snapshot) -> (T, Option<Snapshot>),
{
    let mut curr = self.load();

    loop {
        let (output, next) = f(curr);
        let next = match next {
            Some(next) => next,
            None => return output,
        };

        let res = self.val.compare_exchange(curr.0, next.0, AcqRel, Acquire);

        match res {
            Ok(_) => return output,
            Err(actual) => curr = Snapshot(actual),
        }
    }
}

pub(super) fn transition_to_running(&self) -> TransitionToRunning {
    self.fetch_update_action(|mut next| {
        let action;
        assert!(next.is_notified());

        if !next.is_idle() {
            // This happens if the task is either currently running or if it
            // has already completed, e.g. if it was cancelled during
            // shutdown. Consume the ref-count and return.
            next.ref_dec();
            if next.ref_count() == 0 {
                action = TransitionToRunning::Dealloc;
            } else {
                action = TransitionToRunning::Failed;
            }
        } else {
            // We are able to lock the RUNNING bit.
            next.set_running();
            next.unset_notified();

            if next.is_cancelled() {
                action = TransitionToRunning::Cancelled;
            } else {
                action = TransitionToRunning::Success;
            }
        }
        (action, Some(next))
    })
}

pub(super) fn transition_to_idle(&self) -> TransitionToIdle {
    self.fetch_update_action(|curr| {
        assert!(curr.is_running());

        if curr.is_cancelled() {
            return (TransitionToIdle::Cancelled, None);
        }

        let mut next = curr;
        let action;
        next.unset_running();

        if !next.is_notified() {
            // Polling the future consumes the ref-count of the Notified.
            next.ref_dec();
            if next.ref_count() == 0 {
                action = TransitionToIdle::OkDealloc;
            } else {
                action = TransitionToIdle::Ok;
            }
        } else {
            // The caller will schedule a new notification, so we create a
            // new ref-count for the notification. Our own ref-count is kept
            // for now, and the caller will drop it shortly.
            next.ref_inc();
            action = TransitionToIdle::OkNotified;
        }

        (action, Some(next))
    })
}

#[tokio::main]
async fn main() {
  let metrics = tokio::runtime::Handle::current().metrics();
  // pending() 从不保存传给它的 waker
  drop(tokio::spawn(std::future::pending::<()>()));
  tokio::task::yield_now().await;
  println!("alive: {}", metrics.num_alive_tasks()); // alive: 1
}

pub(super) fn transition_to_complete(&self) -> Snapshot {
    const DELTA: usize = RUNNING | COMPLETE;

    let prev = Snapshot(self.val.fetch_xor(DELTA, AcqRel));
    assert!(prev.is_running());
    assert!(!prev.is_complete());

    Snapshot(prev.0 ^ DELTA)
}

pub(super) fn transition_to_shutdown(&self) -> bool {
    let mut prev = Snapshot(0);

    let _ = self.fetch_update(|mut snapshot| {
        prev = snapshot;

        if snapshot.is_idle() {
            snapshot.set_running();
        }

        // If the task was not idle, the thread currently running the task
        // will notice the cancelled bit and cancel it once the poll
        // completes.
        snapshot.set_cancelled();
        Some(snapshot)
    });

    prev.is_idle()
}

pub(super) fn ref_inc(&self) {
    // ...
    let prev = self.val.fetch_add(REF_ONE, Relaxed);

    // If the reference count overflowed, abort.
    if prev > isize::MAX as usize {
        process::abort();
    }
}