type Mutex struct {
    state int32
    sema  uint32
}

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

func (m *Mutex) Lock() {
    // 判斷當(dāng)前鎖的狀態(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 {
    // 判斷是否允許進(jìn)入自旋 兩個(gè)條件，條件1是當(dāng)前鎖不能處于饑餓狀態(tài)
    // 條件2是在runtime_canSpin內(nèi)實(shí)現(xiàn)，其邏輯是在多核CPU運(yùn)行，自旋的次數(shù)小于4
        if old&(mutexLocked|mutexStarving) == mutexLocked && runtime_canSpin(iter) {
      // !awoke 判斷當(dāng)前goroutine不是在喚醒狀態(tài)
      // old&mutexWoken == 0 表示沒有其他正在喚醒的goroutine
      // old>>mutexWaiterShift != 0 表示等待隊(duì)列中有正在等待的goroutine
      // atomic.CompareAndSwapInt32(&m.state, old, old|mutexWoken) 嘗試將當(dāng)前鎖的低2位的Woken狀態(tài)位設(shè)置為1，表示已被喚醒, 這是為了通知在解鎖Unlock()中不要再喚醒其他的waiter了
            if !awoke && old&mutexWoken == 0 && old>>mutexWaiterShift != 0 &&
                atomic.CompareAndSwapInt32(&m.state, old, old|mutexWoken) {
                    // 設(shè)置當(dāng)前goroutine喚醒成功
          awoke = true
            }
      // 進(jìn)行自旋
            runtime_doSpin()
      // 自旋次數(shù)
            iter++
      // 記錄當(dāng)前鎖的狀態(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) {
  // 這里表示解鎖了一個(gè)沒有上鎖的鎖，則直接發(fā)生panic
    if (new+mutexLocked)&mutexLocked == 0 {
        throw("sync: unlock of unlocked mutex")
    }
  // 正常模式的釋放鎖邏輯
    if new&mutexStarving == 0 {
        old := new
        for {
      // 如果沒有等待者則直接返回即可
      // 如果鎖處于加鎖的狀態(tài)，表示已經(jīng)有g(shù)oroutine獲取到了鎖，可以返回
      // 如果鎖處于喚醒狀態(tài)，這表明有等待的goroutine被喚醒了，不用嘗試獲取其他goroutine了
      // 如果鎖處于饑餓模式，鎖之后會直接給等待隊(duì)頭goroutine
            if old>>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken|mutexStarving) != 0 {
                return
            }
            // 搶占喚醒標(biāo)志位，這里是想要把鎖的狀態(tài)設(shè)置為被喚醒，然后waiter隊(duì)列-1
            new = (old - 1<<mutexWaiterShift) | mutexWoken
            if atomic.CompareAndSwapInt32(&m.state, old, new) {
        // 搶占成功喚醒一個(gè)goroutine
                runtime_Semrelease(&m.sema, false, 1)
                return
            }
      // 執(zhí)行搶占不成功時(shí)重新更新一下狀態(tài)信息，下次for循環(huán)繼續(xù)處理
            old = m.state
        }
    } else {
    // 饑餓模式釋放鎖邏輯，直接喚醒等待隊(duì)列g(shù)oroutine
        runtime_Semrelease(&m.sema, true, 1)
    }
}

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

func (m *Mutex) TryLock() bool {
  // 記錄當(dāng)前狀態(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
}