簡(jiǎn)述

Golang中的鎖機(jī)制主要包含互斥鎖和讀寫鎖

互斥鎖

互斥鎖是傳統(tǒng)并發(fā)程序?qū)蚕碣Y源進(jìn)行控制訪問(wèn)的主要手段。在Go中主要使用 sync.Mutex的結(jié)構(gòu)體表示。

一個(gè)簡(jiǎn)單的示例：

func mutex() {
 var mu sync.Mutex
 mu.Lock()
 fmt.Println("locked")
 mu.Unlock()
}

或者也可以使用defer來(lái)實(shí)現(xiàn)，這在整個(gè)函數(shù)流程中全部要加鎖時(shí)特別有用，還有一個(gè)好處就是可以防止忘記Unlock

func mutex() {
 var mu sync.Mutex
 mu.Lock()
 defer mu.Unlock()
 fmt.Println("locked")
}

互斥鎖是開箱即用的，只需要申明sync.Mutex即可直接使用

var mu sync.Mutex

互斥鎖應(yīng)該是成對(duì)出現(xiàn)，在同步語(yǔ)句不可以再對(duì)鎖加鎖，看下面的示例：

func mutex() {
 var mu sync.Mutex
 mu.Lock()
 fmt.Println("parent locked")
 mu.Lock()
 fmt.Println("sub locked")
 mu.Unlock()
 mu.Unlock()
}

此時(shí)則會(huì)出現(xiàn)fatal error: all goroutines are asleep - deadlock!錯(cuò)誤

同樣，如果多次對(duì)一個(gè)鎖解鎖，則會(huì)出現(xiàn)fatal error: sync: unlock of unlocked mutex錯(cuò)誤

func mutex() {
 var mu sync.Mutex
 mu.Lock()
 fmt.Println("locked")
 mu.Unlock()
 mu.Unlock()
}

那么在goroutine中是否對(duì)外部鎖加鎖呢？

func mutex() {
 var mu sync.Mutex
 fmt.Println("parent lock start")
 mu.Lock()
 fmt.Println("parent locked")
 for i := 0; i <= 2; i++ {
 go func(i int) {
 fmt.Printf("sub(%d) lock startn", i)
 mu.Lock()
 fmt.Printf("sub(%d) lockedn", i)
 time.Sleep(time.Microsecond * 30)
 mu.Unlock()
 fmt.Printf("sub(%d) unlockn", i)
 }(i)
 }
 time.Sleep(time.Second * 2)
 mu.Unlock()
 fmt.Println("parent unlock")
 time.Sleep(time.Second * 2)
}

先看上面的函數(shù)執(zhí)行結(jié)果

parent lock start
parent locked
sub(0) lock start
sub(2) lock start
sub(1) lock start
parent unlock // 必須等到父級(jí)先解鎖，后面則會(huì)阻塞
sub(0) locked // 解鎖后子goroutine才能執(zhí)行鎖定
sub(0) unlock
sub(2) locked
sub(2) unlock
sub(1) locked
sub(1) unlock

為了方便調(diào)試，使用了time.Sleep()來(lái)延遲保證goroutine的執(zhí)行 從結(jié)果中可以看出，當(dāng)所有的goroutine遇到Lock時(shí)都會(huì)阻塞，而當(dāng)main函數(shù)中的Unlock執(zhí)行后，會(huì)有一個(gè)優(yōu)先（無(wú)序）的goroutine來(lái)占得鎖，其它的則再次進(jìn)入阻塞狀態(tài)。

總結(jié)：

• 互斥鎖必須成對(duì)出現(xiàn)
• 同級(jí)別互斥鎖不能嵌套使用
• 父級(jí)中如果存在鎖，當(dāng)在goroutine中執(zhí)行重復(fù)鎖定操作時(shí)goroutine將被阻塞，直到原互斥鎖解鎖，多個(gè)goroutine將會(huì)爭(zhēng)搶當(dāng)前鎖資源，其它繼續(xù)阻塞。

讀寫鎖

讀寫鎖和互斥鎖不同之處在于，可以分別針對(duì)讀操作和寫操作進(jìn)行分別鎖定，這樣對(duì)于性能有一定的提升。 讀寫鎖，對(duì)于多個(gè)寫操作，以及寫操作和讀操作之前都是互斥的這一點(diǎn)基本等同于互斥鎖。 但是對(duì)于同時(shí)多個(gè)讀操作之前卻非互斥關(guān)系，這也是相讀寫鎖性能高于互斥鎖的主要原因。

讀寫鎖也是開箱即用型的

var rwm = sync.RWMutex

讀寫鎖分為寫鎖和讀鎖：

• 寫鎖定和寫解鎖

rwm.Lock()
rwm.Unlock()

• 讀鎖定和讀解鎖

rwm.RLock()
rwm.RUnlock()

讀寫鎖的讀鎖和寫鎖不能交叉相互解鎖，否則會(huì)發(fā)生panic，如：

func rwMutex() {
 var rwm sync.RWMutex

 rwm.Lock()
 fmt.Println("locked")
 rwm.RUnlock()
}

fatal error: sync: RUnlock of unlocked RWMutex

對(duì)于讀寫鎖，同一資源可以同時(shí)有多個(gè)讀鎖定，如：

func rwMutex() {
 var rwm sync.RWMutex

 rwm.RLock()
 rwm.RLock()
 rwm.RLock()
 fmt.Println("locked")
 rwm.RUnlock()
 rwm.RUnlock()
 rwm.RUnlock()
}

但對(duì)于寫鎖定只能有一個(gè)（和互斥鎖相同），同時(shí)使用多個(gè)會(huì)產(chǎn)生deadlock的panic，如：

func rwMutex() {
 var rwm sync.RWMutex

 rwm.Lock()
 rwm.Lock()
 rwm.Lock()
 fmt.Println("locked")
 rwm.Unlock()
 rwm.Unlock()
 rwm.Unlock()
}

在goroutine中，寫解鎖會(huì)試圖喚醒所有想要進(jìn)行讀鎖定而被阻塞的goroutine。

而讀解鎖會(huì)在已無(wú)任何讀鎖定的情況下，試圖喚醒一個(gè)想進(jìn)行寫鎖定而被阻塞的goroutine。

下面看一個(gè)完整示例：

func rwMutex() {
 var rwm sync.RWMutex

 for i := 0; i <= 2; i++ {
 go func(i int) {
 fmt.Printf("go(%d) start lockn", i)
 rwm.RLock()
 fmt.Printf("go(%d) lockedn", i)
 time.Sleep(time.Second * 2)
 rwm.RUnlock()
 fmt.Printf("go(%d) unlockn", i)
 }(i)
 }
 // 先sleep一小會(huì)，保證for的goroutine都會(huì)執(zhí)行
 time.Sleep(time.Microsecond * 100)
 fmt.Println("main start lock")
 // 當(dāng)子進(jìn)程都執(zhí)行時(shí)，且子進(jìn)程所有的資源都已經(jīng)Unlock了
 // 父進(jìn)程才會(huì)執(zhí)行
 rwm.Lock()
 fmt.Println("main locked")
 time.Sleep(time.Second)
 rwm.Unlock()
}

go(0) start lock
go(0) locked
go(1) start lock
go(1) locked
go(2) start lock
go(2) locked
main start lock
go(2) unlock
go(0) unlock
go(1) unlock
main locked

反復(fù)執(zhí)行上述示例中，可以看到，寫鎖定會(huì)阻塞goroutine 最開始先在main中sleep 100ms ，保證子的goroutine會(huì)全部執(zhí)行，而每個(gè)子goroutine會(huì)sleep 2s。 此時(shí)會(huì)阻塞整個(gè)main進(jìn)程，當(dāng)所有子goroutine執(zhí)行結(jié)束，讀解鎖后，main的寫鎖定才會(huì)執(zhí)行。

再看一個(gè)讀鎖定示例：

func rwMutex5() {
 var rwm sync.RWMutex

 for i := 0; i <= 2; i++ {
 go func(i int) {
 fmt.Printf("go(%d) start lockn", i)
 rwm.RLock()
 fmt.Printf("go(%d) lockedn", i)
 time.Sleep(time.Second * 2)
 rwm.RUnlock()
 fmt.Printf("go(%d) unlockn", i)
 }(i)
 }

 fmt.Println("main start lock")
 rwm.RLock()
 fmt.Println("main locked")
 time.Sleep(time.Second * 10)
}

main start lock
main locked
go(1) start lock
go(1) locked
go(2) start lock
go(2) locked
go(0) start lock
go(0) locked
go(0) unlock
go(1) unlock
go(2) unlock

可以看到讀鎖定卻并不會(huì)阻塞goroutine。

總結(jié)：

• 讀鎖定和寫鎖定對(duì)于寫操作都是互斥的
• 讀鎖定支持多級(jí)嵌套，但寫鎖定無(wú)法嵌套執(zhí)行
• 如果有寫鎖定，當(dāng)多個(gè)讀解鎖全部執(zhí)行完成后，則會(huì)喚起執(zhí)行寫鎖定
• 寫鎖定會(huì)阻塞goroutine（在Lock()時(shí)和互斥鎖一樣，RLock()時(shí)先也是等到RUnlock()先執(zhí)行，才有鎖定機(jī)會(huì)）