type Mutex struct {
 state int32   //互斥鎖上鎖狀態(tài)枚舉值如下所示
 sema uint32  //信號量，向處于Gwaitting的G發(fā)送信號
}

const (
 mutexLocked = 1 << iota // 1 互斥鎖是鎖定的
 mutexWoken       // 2 喚醒鎖
 mutexWaiterShift = iota // 2 統(tǒng)計阻塞在這個互斥鎖上的goroutine數(shù)目需要移位的數(shù)值
)

//go:linkname sync_runtime_canSpin sync.runtime_canSpin
func sync_runtime_canSpin(i int) bool {
 if i >= active_spin || ncpu <= 1 || gomaxprocs <= int32(sched.npidle+sched.nmspinning)+1 {
 return false
 }
 if p := getg().m.p.ptr(); !runqempty(p) {
 return false
 }
 return true
}

//go:linkname sync_runtime_doSpin sync.runtime_doSpin
func sync_runtime_doSpin() {
 procyield(active_spin_cnt)
}

//go:linkname sync_runtime_SemacquireMutex sync.runtime_SemacquireMutex
func sync_runtime_SemacquireMutex(addr *uint32) {
 semacquire(addr, semaBlockProfile|semaMutexProfile)
}

//go:linkname sync_runtime_Semrelease sync.runtime_Semrelease
func sync_runtime_Semrelease(addr *uint32) {
 semrelease(addr)
}
Mutex的Lock函數(shù)定義如下

func (m *Mutex) Lock() {
    //先使用CAS嘗試獲取鎖
 if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
        //這里是-race不需要管它
 if race.Enabled {
  race.Acquire(unsafe.Pointer(m))
 }
        //成功獲取返回
 return
 }

 awoke := false //循環(huán)標記
 iter := 0    //循環(huán)計數(shù)器
 for {
 old := m.state //獲取當前鎖狀態(tài)
 new := old | mutexLocked //將當前狀態(tài)最后一位指定1
 if old&mutexLocked != 0 { //如果所以被占用
  if runtime_canSpin(iter) { //檢查是否可以進入自旋鎖
  if !awoke && old&mutexWoken == 0 && old>>mutexWaiterShift != 0 &&
   atomic.CompareAndSwapInt32(&m.state, old, old|mutexWoken) { 
                    //awoke標記為true
   awoke = true
  }
                //進入自旋狀態(tài)
  runtime_doSpin()
  iter++
  continue
  }
            //沒有獲取到鎖，當前G進入Gwaitting狀態(tài)
  new = old + 1<<mutexWaiterShift
 }
 if awoke {
  if new&mutexWoken == 0 {
  throw("sync: inconsistent mutex state")
  }
            //清除標記
  new &^= mutexWoken
 }
        //更新狀態(tài)
 if atomic.CompareAndSwapInt32(&m.state, old, new) {
  if old&mutexLocked == 0 {
  break
  }
             
            // 鎖請求失敗,進入休眠狀態(tài),等待信號喚醒后重新開始循環(huán)
  runtime_SemacquireMutex(&m.sema)
  awoke = true
  iter = 0
 }
 }

 if race.Enabled {
 race.Acquire(unsafe.Pointer(m))
 }
}
Mutex的Unlock函數(shù)定義如下

func (m *Mutex) Unlock() {
 if race.Enabled {
 _ = m.state
 race.Release(unsafe.Pointer(m))
 }

 // 移除標記
 new := atomic.AddInt32(&m.state, -mutexLocked)
 if (new+mutexLocked)&mutexLocked == 0 {
 throw("sync: unlock of unlocked mutex")
 }

 old := new
 for {
 //當休眠隊列內(nèi)的等待計數(shù)為0或者自旋狀態(tài)計數(shù)器為0，退出
 if old>>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken) != 0 {
  return
 }
 // 減少等待次數(shù)，添加清除標記
 new = (old - 1<<mutexWaiterShift) | mutexWoken
 if atomic.CompareAndSwapInt32(&m.state, old, new) {
            // 釋放鎖,發(fā)送釋放信號
  runtime_Semrelease(&m.sema)
  return
 }
 old = m.state
 }
}