Go語言的互斥鎖的詳細使用

type Mutex struct {
	state int32
	sema  uint32
}

const (
   mutexLocked = 1 << iota // 表示互斥鎖的鎖定狀態
   mutexWoken // 表示從正常模式被從喚醒
   mutexStarving // 當前的互斥鎖進入飢餓狀態
   mutexWaiterShift = iota // 當前互斥鎖上等待者的數量
)

func (m *Mutex) Lock() {
	// 判斷當前鎖的狀態，如果鎖是完全空閒的，即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是當前鎖不能處於飢餓狀態
    // 條件2是在runtime_canSpin內實現，其邏輯是在多核CPU執行，自旋的次數小於4
		if old&(mutexLocked|mutexStarving) == mutexLocked && runtime_canSpin(iter) {
      // !awoke 判斷當前goroutine不是在喚醒狀態
      // old&mutexWoken == 0 表示沒有其他正在喚醒的goroutine
      // old>>mutexWaiterShift != 0 表示等待佇列中有正在等待的goroutine
      // atomic.CompareAndSwapInt32(&m.state, old, old|mutexWoken) 嘗試將當前鎖的低2位的Woken狀態位設定為1，表示已被喚醒, 這是為了通知在解鎖Unlock()中不要再喚醒其他的waiter了
			if !awoke && old&mutexWoken == 0 && old>>mutexWaiterShift != 0 &&
				atomic.CompareAndSwapInt32(&m.state, old, old|mutexWoken) {
					// 設定當前goroutine喚醒成功
          awoke = true
			}
      // 進行自旋
			runtime_doSpin()
      // 自旋次數
			iter++
      // 記錄當前鎖的狀態
			old = m.state
			continue
		}
}

// / go/go1.18/src/runtime/proc.go
const active_spin     = 4
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
}

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

    // 基於old狀態宣告到一個新狀態
		new := old
		// 新狀態處於非飢餓的條件下才可以加鎖
		if old&mutexStarving == 0 {
			new |= mutexLocked
		}

//如果old已經處於加鎖或者飢餓狀態，則等待者按照FIFO的順序排隊
if old&(mutexLocked|mutexStarving) != 0 {
			new += 1 << mutexWaiterShift
		}

// 如果當前鎖處於飢餓模式，並且已被加鎖，則將低3位的Starving狀態位設定為1，表示飢餓
if starving && old&mutexLocked != 0 {
			new |= mutexStarving
		}

// 當前goroutine的waiter被喚醒,則重置flag
if awoke {
			// 喚醒狀態不一致，直接丟擲異常
			if new&mutexWoken == 0 {
				throw("sync: inconsistent mutex state")
			}
     // 新狀態清除喚醒標記，因為後面的goroutine只會阻塞或者搶鎖成功
     // 如果是掛起狀態，那就需要等待其他釋放鎖的goroutine來喚醒。
     // 假如其他goroutine在unlock的時候發現Woken的位置不是0，則就不會去喚醒，那該goroutine就無法在被喚醒後加鎖
			new &^= mutexWoken
}

// 這裡嘗試將鎖的狀態更新為期望狀態
if atomic.CompareAndSwapInt32(&m.state, old, new) {
  // 如果原來鎖的狀態是沒有加鎖的並且不處於飢餓狀態，則表示當前goroutine已經獲取到鎖了，直接推出即可
			if old&(mutexLocked|mutexStarving) == 0 {
				break // locked the mutex with CAS
			}
			// 到這裡就表示goroutine還沒有獲取到鎖，waitStartTime是goroutine開始等待的時間，waitStartTime != 0就表示當前goroutine已經等待過了，則需要將其放置在等待佇列隊頭，否則就排到佇列隊尾
			queueLifo := waitStartTime != 0
			if waitStartTime == 0 {
				waitStartTime = runtime_nanotime()
			}
      // 阻塞等待
			runtime_SemacquireMutex(&m.sema, queueLifo, 1)
      // 被號誌喚醒後檢查當前goroutine是否應該表示為飢餓
     // 1. 當前goroutine已經飢餓
     // 2. goroutine已經等待了1ms以上
			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")
				}
        // 當前goroutine已經獲取了鎖，等待佇列-1
				delta := int32(mutexLocked - 1<<mutexWaiterShift
         // 當前goroutine非飢餓狀態 或者 等待佇列只剩下一個waiter，則退出飢餓模式(清除飢餓標識位)              
				if !starving || old>>mutexWaiterShift == 1 {
					delta -= mutexStarving
				}
        // 更新狀態值並中止for迴圈，拿到鎖退出
				atomic.AddInt32(&m.state, delta)
				break
			}
      // 設定當前goroutine為喚醒狀態，且重置自璇次數
			awoke = true
			iter = 0
		} else {
      // 鎖被其他goroutine佔用了，還原狀態繼續for迴圈
			old = m.state
		}

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) {
  // 這裡表示解鎖了一個沒有上鎖的鎖，則直接發生panic
	if (new+mutexLocked)&mutexLocked == 0 {
		throw("sync: unlock of unlocked mutex")
	}
  // 正常模式的釋放鎖邏輯
	if new&mutexStarving == 0 {
		old := new
		for {
      // 如果沒有等待者則直接返回即可
      // 如果鎖處於加鎖的狀態，表示已經有goroutine獲取到了鎖，可以返回
      // 如果鎖處於喚醒狀態，這表明有等待的goroutine被喚醒了，不用嘗試獲取其他goroutine了
      // 如果鎖處於飢餓模式，鎖之後會直接給等待隊頭goroutine
			if old>>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken|mutexStarving) != 0 {
				return
			}
			// 搶佔喚醒標誌位，這裡是想要把鎖的狀態設定為被喚醒，然後waiter佇列-1
			new = (old - 1<<mutexWaiterShift) | mutexWoken
			if atomic.CompareAndSwapInt32(&m.state, old, new) {
        // 搶佔成功喚醒一個goroutine
				runtime_Semrelease(&m.sema, false, 1)
				return
			}
      // 執行搶佔不成功時重新更新一下狀態資訊，下次for迴圈繼續處理
			old = m.state
		}
	} else {
    // 飢餓模式釋放鎖邏輯，直接喚醒等待佇列goroutine
		runtime_Semrelease(&m.sema, true, 1)
	}
}

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


	return true
}