自旋鎖和互斥鎖執行個體_Golang互斥鎖内部實作的執行個體詳解

本篇文章主要介紹了詳解Golang互斥鎖内部實作，小編覺得挺不錯的，現在分享給大家，也給大家做個參考。一起跟随小編過來看看吧

go語言提供了一種開箱即用的共享資源的方式，互斥鎖(sync.Mutex), sync.Mutex的零值表示一個沒有被鎖的，可以直接使用的，一個goroutine獲得互斥鎖後其他的goroutine隻能等到這個gorutine釋放該互斥鎖,在Mutex結構中隻公開了兩個函數，分别是Lock和Unlock，在使用互斥鎖的時候非常簡單，本文并不闡述使用。

在使用sync.Mutex的時候千萬不要做值拷貝，因為這樣可能會導緻鎖失效。當我們打開我們的IDE時候跳到我們的sync.Mutex 代碼中會發現它有如下的結構:

type Mutex struct {

state int32 //互斥鎖上鎖狀态枚舉值如下所示

sema uint32 //信号量，向處于Gwaitting的G發送信号

}

const (

mutexLocked = 1 << iota // 1 互斥鎖是鎖定的

mutexWoken // 2 喚醒鎖

mutexWaiterShift = iota // 2 統計阻塞在這個互斥鎖上的goroutine數目需要移位的數值

)

上面的state值分别為 0(可用) 1(被鎖) 2~31等待隊列計數

下面是互斥鎖的源碼，這裡會有四個比較重要的方法需要提前解釋，分别是runtime_canSpin，runtime_doSpin，runtime_SemacquireMutex，runtime_Semrelease，

1、runtime_canSpin：比較保守的自旋，golang中自旋鎖并不會一直自旋下去，在runtime包中runtime_canSpin方法做了一些限制, 傳遞過來的iter大等于4或者cpu核數小等于1，最大邏輯處理器大于1，至少有個本地的P隊列，并且本地的P隊列可運作G隊列為空。

//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

}

2、 runtime_doSpin：會調用procyield函數，該函數也是彙編語言實作。函數内部循環調用PAUSE指令。PAUSE指令什麼都不做，但是會消耗CPU時間，在執行PAUSE指令時，CPU不會對它做不必要的優化。

//go:linkname sync_runtime_doSpin sync.runtime_doSpin

func sync_runtime_doSpin() {

procyield(active_spin_cnt)

}

3、runtime_SemacquireMutex:

//go:linkname sync_runtime_SemacquireMutex sync.runtime_SemacquireMutex

func sync_runtime_SemacquireMutex(addr *uint32) {

semacquire(addr, semaBlockProfile|semaMutexProfile)

}

4、runtime_Semrelease:

//go:linkname sync_runtime_Semrelease sync.runtime_Semrelease

func sync_runtime_Semrelease(addr *uint32) {

semrelease(addr)

}

Mutex的Lock函數定義如下

func (m *Mutex) Lock() {

//先使用CAS嘗試擷取鎖

if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {

//這裡是-race不需要管它

if race.Enabled {

race.Acquire(unsafe.Pointer(m))

}

//成功擷取傳回

return

}

awoke := false //循環标記

iter := 0 //循環計數器

for {

old := m.state //擷取目前鎖狀态

new := old | mutexLocked //将目前狀态最後一位指定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

}

//進入自旋狀态

runtime_doSpin()

iter++

continue

}

//沒有擷取到鎖，目前G進入Gwaitting狀态

new = old + 1<

}

if awoke {

if new&mutexWoken == 0 {

throw("sync: inconsistent mutex state")

}

//清除标記

new &^= mutexWoken

}

//更新狀态

if atomic.CompareAndSwapInt32(&m.state, old, new) {

if old&mutexLocked == 0 {

break

}

// 鎖請求失敗,進入休眠狀态,等待信号喚醒後重新開始循環

runtime_SemacquireMutex(&m.sema)

awoke = true

iter = 0

}

}

if race.Enabled {

race.Acquire(unsafe.Pointer(m))

}

}

Mutex的Unlock函數定義如下

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 {

//當休眠隊列内的等待計數為0或者自旋狀态計數器為0，退出

if old>>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken) != 0 {

return

}

// 減少等待次數，添加清除标記

new = (old - 1<

if atomic.CompareAndSwapInt32(&m.state, old, new) {

// 釋放鎖,發送釋放信号

runtime_Semrelease(&m.sema)

return

}

old = m.state

}

}

互斥鎖無沖突是最簡單的情況了，有沖突時，首先進行自旋，，因為大多數的Mutex保護的代碼段都很短，經過短暫的自旋就可以獲得；如果自旋等待無果，就隻好通過信号量來讓目前Goroutine進入Gwaitting狀态。