go語言提供了一種開箱即用的共享資源的方式，互斥鎖(sync.Mutex), sync.Mutex的零值表示一個沒有被鎖的，可以直接使用的，一個goroutine獲得互斥鎖后其他的goroutine只能等到這個gorutine釋放該互斥鎖,在Mutex結(jié)構(gòu)中只公開了兩個函數(shù)，分別是Lock和Unlock，在使用互斥鎖的時(shí)候非常簡單，本文并不闡述使用。
在使用sync.Mutex的時(shí)候千萬不要做值拷貝，因?yàn)檫@樣可能會導(dǎo)致鎖失效。當(dāng)我們打開我們的IDE時(shí)候跳到我們的sync.Mutex 代碼中會發(fā)現(xiàn)它有如下的結(jié)構(gòu):
type Mutex struct {
state int32 //互斥鎖上鎖狀態(tài)枚舉值如下所示
sema uint32 //信號量，向處于Gwaitting的G發(fā)送信號
}
const (
mutexLocked = 1 iota // 1 互斥鎖是鎖定的
mutexWoken // 2 喚醒鎖
mutexWaiterShift = iota // 2 統(tǒng)計(jì)阻塞在這個互斥鎖上的goroutine數(shù)目需要移位的數(shù)值
)
上面的state值分別為 0(可用) 1(被鎖) 2~31等待隊(duì)列計(jì)數(shù)
下面是互斥鎖的源碼，這里會有四個比較重要的方法需要提前解釋，分別是runtime_canSpin，runtime_doSpin，runtime_SemacquireMutex，runtime_Semrelease，
1、runtime_canSpin：比較保守的自旋，golang中自旋鎖并不會一直自旋下去，在runtime包中runtime_canSpin方法做了一些限制, 傳遞過來的iter大等于4或者cpu核數(shù)小等于1，最大邏輯處理器大于1，至少有個本地的P隊(duì)列，并且本地的P隊(duì)列可運(yùn)行G隊(duì)列為空。
//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：會調(diào)用procyield函數(shù)，該函數(shù)也是匯編語言實(shí)現(xiàn)。函數(shù)內(nèi)部循環(huán)調(diào)用PAUSE指令。PAUSE指令什么都不做，但是會消耗CPU時(shí)間，在執(zhí)行PAUSE指令時(shí)，CPU不會對它做不必要的優(yōu)化。
//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函數(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)標(biāo)記
iter := 0 //循環(huán)計(jì)數(shù)器
for {
old := m.state //獲取當(dāng)前鎖狀態(tài)
new := old | mutexLocked //將當(dāng)前狀態(tài)最后一位指定1
if oldmutexLocked != 0 { //如果所以被占用
if runtime_canSpin(iter) { //檢查是否可以進(jìn)入自旋鎖
if !awoke oldmutexWoken == 0 old>>mutexWaiterShift != 0
atomic.CompareAndSwapInt32(m.state, old, old|mutexWoken) {
//awoke標(biāo)記為true
awoke = true
}
//進(jìn)入自旋狀態(tài)
runtime_doSpin()
iter++
continue
}
//沒有獲取到鎖，當(dāng)前G進(jìn)入Gwaitting狀態(tài)
new = old + 1mutexWaiterShift
}
if awoke {
if newmutexWoken == 0 {
throw("sync: inconsistent mutex state")
}
//清除標(biāo)記
new ^= mutexWoken
}
//更新狀態(tài)
if atomic.CompareAndSwapInt32(m.state, old, new) {
if oldmutexLocked == 0 {
break
}
// 鎖請求失敗,進(jìn)入休眠狀態(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))
}
// 移除標(biāo)記
new := atomic.AddInt32(m.state, -mutexLocked)
if (new+mutexLocked)mutexLocked == 0 {
throw("sync: unlock of unlocked mutex")
}
old := new
for {
//當(dāng)休眠隊(duì)列內(nèi)的等待計(jì)數(shù)為0或者自旋狀態(tài)計(jì)數(shù)器為0，退出
if old>>mutexWaiterShift == 0 || old(mutexLocked|mutexWoken) != 0 {
return
}
// 減少等待次數(shù)，添加清除標(biāo)記
new = (old - 1mutexWaiterShift) | mutexWoken
if atomic.CompareAndSwapInt32(m.state, old, new) {
// 釋放鎖,發(fā)送釋放信號
runtime_Semrelease(m.sema)
return
}
old = m.state
}
}
互斥鎖無沖突是最簡單的情況了，有沖突時(shí)，首先進(jìn)行自旋，，因?yàn)榇蠖鄶?shù)的Mutex保護(hù)的代碼段都很短，經(jīng)過短暫的自旋就可以獲得；如果自旋等待無果，就只好通過信號量來讓當(dāng)前Goroutine進(jìn)入Gwaitting狀態(tài)。
以上就是本文的全部內(nèi)容，希望對大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。
您可能感興趣的文章:- GO語言并發(fā)編程之互斥鎖、讀寫鎖詳解
- 詳解golang RWMutex讀寫互斥鎖源碼分析
- Go語言實(shí)現(xiàn)互斥鎖、隨機(jī)數(shù)、time、List
