type Mutex struct {
    state int32
    sema  uint32
}

// Lock mutex 的鎖方法。
func (m *Mutex) Lock() {
    // 快速上鎖.
    if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
        if race.Enabled {
            race.Acquire(unsafe.Pointer(m))
        }
        return
    }
    // 快速上鎖失敗，將進行操作較多的上鎖動作。
    m.lockSlow()
}
func (m *Mutex) lockSlow() {
  var waitStartTime int64  // 記錄當前 goroutine 的等待時間
  starving := false // 是否饑餓
  awoke := false // 是否被喚醒
  iter := 0 // 自旋次數(shù)
  old := m.state // 當前 mutex 的狀態(tài)
  for {
    // 當前 mutex 的狀態(tài)已上鎖，并且非饑餓模式，并且符合自旋條件
    if old&(mutexLocked|mutexStarving) == mutexLocked && runtime_canSpin(iter) {
      // 當前還沒設(shè)置過喚醒標識
      if !awoke && old&mutexWoken == 0 && old>>mutexWaiterShift != 0 &&
        atomic.CompareAndSwapInt32(&m.state, old, old|mutexWoken) {
        awoke = true
      }
      runtime_doSpin()
      iter++
      old = m.state
      continue
    }
    new := old
    // 如果不是饑餓狀態(tài)，則嘗試上鎖
    // 如果是饑餓狀態(tài)，則不會上鎖，因為當前的 goroutine 將會被阻塞并添加到等待喚起隊列的隊尾
    if old&mutexStarving == 0 {
      new |= mutexLocked
    }
    // 等待隊列數(shù)量 + 1
    if old&(mutexLocked|mutexStarving) != 0 {
      new += 1 << mutexWaiterShift
    }
    // 如果 goroutine 之前是饑餓模式，則此次也設(shè)置為饑餓模式
    if starving && old&mutexLocked != 0 {
      new |= mutexStarving
    }
    //
    if awoke {
      // 如果狀態(tài)不符合預(yù)期，則報錯
      if new&mutexWoken == 0 {
        throw("sync: inconsistent mutex state")
      }
      // 新狀態(tài)值需要清除喚醒標識，因為當前 goroutine 將會上鎖或者再次 sleep
      new &^= mutexWoken
    }
    // CAS 嘗試性修改狀態(tài)，修改成功則表示獲取到鎖資源
    if atomic.CompareAndSwapInt32(&m.state, old, new) {
      // 非饑餓模式，并且未獲取過鎖，則說明此次的獲取鎖是 ok 的，直接 return
      if old&(mutexLocked|mutexStarving) == 0 {
        break
      }
      // 根據(jù)等待時間計算 queueLifo
      queueLifo := waitStartTime != 0
      if waitStartTime == 0 {
        waitStartTime = runtime_nanotime()
      }
      // 到這里，表示未能上鎖成功
      // queueLife = true, 將會把 goroutine 放到等待隊列隊頭
      // queueLife = false, 將會把 goroutine 放到等待隊列隊尾
      runtime_SemacquireMutex(&m.sema, queueLifo, 1)
      // 計算是否符合饑餓模式，即等待時間是否超過一定的時間
      starving = starving || runtime_nanotime()-waitStartTime > starvationThresholdNs
      old = m.state
      // 上一次是饑餓模式
      if old&mutexStarving != 0 {
        if old&(mutexLocked|mutexWoken) != 0 || old>>mutexWaiterShift == 0 {
          throw("sync: inconsistent mutex state")
        }
        delta := int32(mutexLocked - 1<<mutexWaiterShift)
        // 此次不是饑餓模式又或者下次沒有要喚起等待隊列的 goroutine 了
        if !starving || old>>mutexWaiterShift == 1 {
          delta -= mutexStarving
        }
        atomic.AddInt32(&m.state, delta)
        break
      }
      // 此處已不再是饑餓模式了，清除自旋次數(shù)，重新到 for 循環(huán)競爭鎖。
      awoke = true
      iter = 0
    } else {
      old = m.state
    }
  }
  if race.Enabled {
    race.Acquire(unsafe.Pointer(m))
  }
}

// Unlock 對 mutex 解鎖.
// 如果沒有上過鎖，缺調(diào)用此方法解鎖，將會拋出運行時錯誤。
// 它將允許在不同的 Goroutine 上進行上鎖解鎖
func (m *Mutex) Unlock() {
    if race.Enabled {
        _ = m.state
        race.Release(unsafe.Pointer(m))
    }
    // 快速嘗試解鎖
    new := atomic.AddInt32(&m.state, -mutexLocked)
    if new != 0 {
        // 快速解鎖失敗，將進行操作較多的解鎖動作。
        m.unlockSlow(new)
    }
}
func (m *Mutex) unlockSlow(new int32) {
  // 非上鎖狀態(tài)，直接拋出異常
  if (new+mutexLocked)&mutexLocked == 0 {
    throw("sync: unlock of unlocked mutex")
  }
  // 正常模式
  if new&mutexStarving == 0 {
    old := new
    for {
      // 沒有需要喚起的等待隊列
      if old>>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken|mutexStarving) != 0 {
        return
      }
      // 喚起等待隊列并數(shù)量-1
      new = (old - 1<<mutexWaiterShift) | mutexWoken
      if atomic.CompareAndSwapInt32(&m.state, old, new) {
        runtime_Semrelease(&m.sema, false, 1)
        return
      }
      old = m.state
    }
  } else {
    //饑餓模式，將鎖直接給等待隊列的隊頭 goroutine
    runtime_Semrelease(&m.sema, true, 1)
  }
}