type Mutex struct {
    state int32
    sema  uint32
}

// 前三個字段標識了鎖的狀態(tài)  剩下的位來標識當前共有多少個goroutine在等待鎖
const (
   mutexLocked = 1 << iota // 表示互斥鎖的鎖定狀態(tài)
   mutexWoken // 表示從正常模式被從喚醒
   mutexStarving // 當前的互斥鎖進入饑餓狀態(tài)
   mutexWaiterShift = iota // 當前互斥鎖上等待者的數(shù)量
)

func (m *Mutex) Lock() {
    // 判斷當前鎖的狀態(tài)，如果鎖是完全空閑的，即m.state為0，則對其加鎖，將m.state的值賦為1
    if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
        if race.Enabled {
            race.Acquire(unsafe.Pointer(m))
        }
        return
    }
    // Slow path (outlined so that the fast path can be inlined)
    m.lockSlow()
}

func (m *Mutex) lockSlow() {
    var waitStartTime int64 
    starving := false
    awoke := false
    iter := 0
    old := m.state
    ........
}

for {
    // 判斷是否允許進入自旋 兩個條件，條件1是當前鎖不能處于饑餓狀態(tài)
    // 條件2是在runtime_canSpin內(nèi)實現(xiàn)，其邏輯是在多核CPU運行，自旋的次數(shù)小于4
        if old&(mutexLocked|mutexStarving) == mutexLocked && runtime_canSpin(iter) {
      // !awoke 判斷當前goroutine不是在喚醒狀態(tài)
      // old&mutexWoken == 0 表示沒有其他正在喚醒的goroutine
      // old>>mutexWaiterShift != 0 表示等待隊列中有正在等待的goroutine
      // atomic.CompareAndSwapInt32(&m.state, old, old|mutexWoken) 嘗試將當前鎖的低2位的Woken狀態(tài)位設置為1，表示已被喚醒, 這是為了通知在解鎖Unlock()中不要再喚醒其他的waiter了
            if !awoke && old&mutexWoken == 0 && old>>mutexWaiterShift != 0 &&
                atomic.CompareAndSwapInt32(&m.state, old, old|mutexWoken) {
                    // 設置當前goroutine喚醒成功
          awoke = true
            }
      // 進行自旋
            runtime_doSpin()
      // 自旋次數(shù)
            iter++
      // 記錄當前鎖的狀態(tài)
            old = m.state
            continue
        }
}

const active_spin_cnt = 30
func sync_runtime_doSpin() {
    procyield(active_spin_cnt)
}
// asm_amd64.s
TEXT runtime·procyield(SB),NOSPLIT,$0-0
    MOVL    cycles+0(FP), AX
again:
    PAUSE
    SUBL    $1, AX
    JNZ    again
    RET

func (m *Mutex) Unlock() {
    // Fast path: drop lock bit.
    new := atomic.AddInt32(&m.state, -mutexLocked)
    if new != 0 {
        // Outlined slow path to allow inlining the fast path.
        // To hide unlockSlow during tracing we skip one extra frame when tracing GoUnblock.
        m.unlockSlow(new)
    }
}
func (m *Mutex) unlockSlow(new int32) {
  // 這里表示解鎖了一個沒有上鎖的鎖，則直接發(fā)生panic
    if (new+mutexLocked)&mutexLocked == 0 {
        throw("sync: unlock of unlocked mutex")
    }
  // 正常模式的釋放鎖邏輯
    if new&mutexStarving == 0 {
        old := new
        for {
      // 如果沒有等待者則直接返回即可
      // 如果鎖處于加鎖的狀態(tài)，表示已經(jīng)有goroutine獲取到了鎖，可以返回
      // 如果鎖處于喚醒狀態(tài)，這表明有等待的goroutine被喚醒了，不用嘗試獲取其他goroutine了
      // 如果鎖處于饑餓模式，鎖之后會直接給等待隊頭goroutine
            if old>>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken|mutexStarving) != 0 {
                return
            }
            // 搶占喚醒標志位，這里是想要把鎖的狀態(tài)設置為被喚醒，然后waiter隊列-1
            new = (old - 1<<mutexWaiterShift) | mutexWoken
            if atomic.CompareAndSwapInt32(&m.state, old, new) {
        // 搶占成功喚醒一個goroutine
                runtime_Semrelease(&m.sema, false, 1)
                return
            }
      // 執(zhí)行搶占不成功時重新更新一下狀態(tài)信息，下次for循環(huán)繼續(xù)處理
            old = m.state
        }
    } else {
    // 饑餓模式釋放鎖邏輯，直接喚醒等待隊列goroutine
        runtime_Semrelease(&m.sema, true, 1)
    }
}

func (m *Mutex) unlockSlow(new int32) {
  // 這里表示解鎖了一個沒有上鎖的鎖，則直接發(fā)生panic
    if (new+mutexLocked)&mutexLocked == 0 {
        throw("sync: unlock of unlocked mutex")
    }
  // 正常模式的釋放鎖邏輯
    if new&mutexStarving == 0 {
        old := new
        for {
      // 如果沒有等待者則直接返回即可
      // 如果鎖處于加鎖的狀態(tài)，表示已經(jīng)有goroutine獲取到了鎖，可以返回
      // 如果鎖處于喚醒狀態(tài)，這表明有等待的goroutine被喚醒了，不用嘗試獲取其他goroutine了
      // 如果鎖處于饑餓模式，鎖之后會直接給等待隊頭goroutine
            if old>>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken|mutexStarving) != 0 {
                return
            }
            // 搶占喚醒標志位，這里是想要把鎖的狀態(tài)設置為被喚醒，然后waiter隊列-1
            new = (old - 1<<mutexWaiterShift) | mutexWoken
            if atomic.CompareAndSwapInt32(&m.state, old, new) {
        // 搶占成功喚醒一個goroutine
                runtime_Semrelease(&m.sema, false, 1)
                return
            }
      // 執(zhí)行搶占不成功時重新更新一下狀態(tài)信息，下次for循環(huán)繼續(xù)處理
            old = m.state
        }
    } else {
    // 饑餓模式釋放鎖邏輯，直接喚醒等待隊列goroutine
        runtime_Semrelease(&m.sema, true, 1)
    }
}

func (m *Mutex) TryLock() bool {
  // 記錄當前狀態(tài)
    old := m.state
  //  處于加鎖狀態(tài)/饑餓狀態(tài)直接獲取鎖失敗
    if old&(mutexLocked|mutexStarving) != 0 {
        return false
    }
    // 嘗試獲取鎖，獲取失敗直接獲取失敗
    if !atomic.CompareAndSwapInt32(&m.state, old, old|mutexLocked) {
        return false
    }


    return true
}