Go的sync_mutex实现

type Mutex struct {
    state int32    
    sema  uint32   
}                  

func (m *Mutex) Lock() {
    // 快速路径：直接锁定mutex
    // 记为FG同步点：Fast Grab
    if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
        // 仅在没有等待者、没有唤醒事件、没有锁定的情况下执行
        if raceenabled {
            raceAcquire(unsafe.Pointer(m))
        }
        return
    }
    awoke := false
    for {
        old := m.state
        new := old | mutexLocked
        if old&mutexLocked != 0 {
            // 处于锁定状态，增加等待者计数
            new = old + 1<<mutexWaiterShift
        }
        if awoke {
            // goroutine已被唤醒，“消费”唤醒事件，重置标志位
            new &^= mutexWoken
        }
        // 记为G同步点：Grab
        if atomic.CompareAndSwapInt32(&m.state, old, new) {
            // 新旧状态一致，没有被其它goroutine修改
            if old&mutexLocked == 0 {
                // 成功锁定
                break
            }
            // 休眠等待
            runtime_Semacquire(&m.sema)
            awoke = true
        }
        // 新旧状态不一致，重新取状态并尝试锁定
    }
    if raceenabled {
        raceAcquire(unsafe.Pointer(m))
    }
}

func (m *Mutex) Unlock() {
    if raceenabled {
        _ = m.state
        raceRelease(unsafe.Pointer(m))
    }
    // 快速路径：直接解除锁定
    // 记为FD同步点：Fast Drop
    new := atomic.AddInt32(&m.state, -mutexLocked)
    if (new+mutexLocked)&mutexLocked == 0 {
        // 连续解除两次以上
        panic("sync: unlock of unlocked mutex")
    }
    old := new
    for {
        // 如果没有等待者，或已经有等待者被唤醒，或已经有goroutine锁定mutex，
        // 则无需尝试唤醒
        if old>>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken) != 0 {
            return
        }
        // 产生唤醒事件，尝试唤醒某个等待者
        new = (old - 1<<mutexWaiterShift) | mutexWoken
        // 记为W同步点：Wake Up
        if atomic.CompareAndSwapInt32(&m.state, old, new) {
            // 新旧状态一致，没有被其它goroutine修改
            // 尝试唤醒
            runtime_Semrelease(&m.sema)
            return
        }
        // 新旧状态不一致，重新取状态并尝试唤醒
        old = m.state
    }
}