1. 簡介
本文的主要內容是介紹Go中Mutex并發原語，包含Mutex的基本使用，使用的注意事項以及一些實踐建議，
2. 基本使用
2.1 基本定義
Mutex是Go語言中的一種同步原語，全稱為Mutual Exclusion，即互斥鎖，它可以在并發編程中實作對共享資源的互斥訪問，保證同一時刻只有一個協程可以訪問共享資源，Mutex通常用于控制對臨界區的訪問，以避免競態條件的出現，
2.2 使用方式
使用Mutex的基本方法非常簡單，可以通過呼叫Mutex的Lock方法來獲取鎖，然后通過Unlock方法釋放鎖，示例代碼如下：
import "sync"
var mutex sync.Mutex
func main() {
mutex.Lock() // 獲取鎖
// 執行需要同步的操作
mutex.Unlock() // 釋放鎖
}
2.3 使用例子
2.3.1 未使用mutex同步代碼示例
下面是一個使用goroutine訪問共享資源，但沒有使用Mutex進行同步的代碼示例：
package main
import (
"fmt"
"time"
)
var count int
func main() {
for i := 0; i < 1000; i++ {
go add()
}
time.Sleep(1 * time.Second)
fmt.Println("count:", count)
}
func add() {
count++
}
上述代碼中，我們啟動了1000個goroutine，每個goroutine都呼叫add()函式將count變數的值加1，由于count變數是共享資源，因此在多個goroutine同時訪問的情況下會出現競態條件，但是由于沒有使用Mutex進行同步，所以會導致count的值無法正確累加，最終輸出的結果也會出現錯誤，
在這個例子中，由于多個goroutine同時訪問count變數，而不進行同步控制，導致每個goroutine都可能讀取到同樣的count值，進行相同的累加操作，這就會導致最終輸出的count值不是期望的結果，如果我們使用Mutex進行同步控制，就可以避免這種競態條件的出現，
2.3.2 使用mutex解決上述問題
下面是使用Mutex進行同步控制，解決上述代碼中競態條件問題的示例：
package main
import (
"fmt"
"sync"
"time"
)
var (
count int
mutex sync.Mutex
)
func main() {
for i := 0; i < 1000; i++ {
go add()
}
time.Sleep(1 * time.Second)
fmt.Println("count:", count)
}
func add() {
mutex.Lock()
count++
mutex.Unlock()
}
在上述代碼中，我們在全域定義了一個sync.Mutex型別的變數mutex，用于進行同步控制，在add()函式中，我們首先呼叫mutex.Lock()方法獲取mutex的鎖，確保只有一個goroutine可以訪問count變數，然后進行加1操作，最后呼叫mutex.Unlock()方法釋放mutex的鎖，使其他goroutine可以繼續訪問count變數，
通過使用Mutex進行同步控制，我們避免了競態條件的出現，確保了count變數的正確累加，最終輸出的結果也符合預期，
3. 使用注意事項
3.1 Lock/Unlock需要成對出現
下面是一個沒有成對出現Lock和Unlock的代碼例子：
package main
import (
"fmt"
"sync"
)
func main() {
var mutex sync.Mutex
go func() {
mutex.Lock()
fmt.Println("goroutine1 locked the mutex")
}()
go func() {
fmt.Println("goroutine2 trying to lock the mutex")
mutex.Lock()
fmt.Println("goroutine2 locked the mutex")
}()
}
在上述代碼中，我們創建了一個sync.Mutex型別的變數mutex，然后在兩個goroutine中使用了這個mutex，
在第一個goroutine中，我們呼叫了mutex.Lock()方法獲取mutex的鎖，但是沒有呼叫相應的Unlock方法，在第二個goroutine中，我們首先列印了一條資訊，然后呼叫了mutex.Lock()方法嘗試獲取mutex的鎖，由于第一個goroutine沒有釋放mutex的鎖，第二個goroutine就一直阻塞在Lock方法中，一直無法執行，
因此，在使用Mutex的程序中，一定要確保每個Lock方法都有對應的Unlock方法，確保Mutex的正常使用，
3.2 不能對已使用的Mutex作為引數進行傳遞
下面舉一個已使用的Mutex作為引數進行傳遞的代碼的例子:
type Counter struct {
sync.Mutex
Count int
}
func main(){
var c Counter
c.Lock()
defer c.Unlock()
c.Count++
foo(c)
fmt.println("done")
}
func foo(c Counter) {
c.Lock()
defer c.Unlock()
fmt.println("foo done")
}
當一個 mutex 被傳遞給一個函式時，預期的行為應該是該函式在訪問受 mutex 保護的共享資源時，能夠正確地獲取和釋放 mutex，以避免競態條件的發生，
如果我們在Mutex未解鎖的情況下拷貝這個Mutex，就會導致鎖失效的問題，因為Mutex的狀態資訊被拷貝了，拷貝出來的Mutex還是處于鎖定的狀態，而在函式中，當要訪問臨界區資料時，首先肯定是先呼叫Mutex.Lock方法加鎖，而傳入Mutex其實是處于鎖定狀態的，此時函式將永遠無法獲取到鎖，
因此，不能將已使用的Mutex直接作為引數進行傳遞，
3.3 不可重復呼叫Lock/UnLock方法
下面是一個例子，其中對同一個 Mutex 進行了重復加鎖：
package main
import (
"fmt"
"sync"
)
func main() {
var mu sync.Mutex
mu.Lock()
fmt.Println("First Lock")
// 重復加鎖
mu.Lock()
fmt.Println("Second Lock")
mu.Unlock()
mu.Unlock()
}
在這個例子中，我們先對 Mutex 進行了一次加鎖，然后在沒有解鎖的情況下，又進行了一次加鎖操作.
這種情況下，程式會出現死鎖，因為第二次加鎖操作已經被阻塞，等待第一次加鎖的解鎖操作，而第一次加鎖的解鎖操作也被阻塞，等待第二次加鎖的解鎖操作，導致了互相等待的局面，無法繼續執行下去，
Mutex實際上是通過一個int32型別的標志位來實作的，當這個標志位為0時，表示這個Mutex當前沒有被任何goroutine獲取；當標志位為1時，表示這個Mutex當前已經被某個goroutine獲取了，
Mutex的Lock方法實際上就是將這個標志位從0改為1，表示獲取了鎖；Unlock方法則是將標志位從1改為0，表示釋放了鎖，當第二次呼叫Lock方法，此時標記位為1，代表有一個goroutine持有了這個鎖，此時將會被阻塞，而持有該鎖的其實就是當前的goroutine,此時該程式將會永遠阻塞下去，
4. 實踐建議
4.1 Mutex鎖不要同時保護兩份不相關資料
下面是一個例子，使用Mutex同時保護兩份不相關的資料
// net/http transport.go
type Transport struct {
lk sync.Mutex
idleConn map[string][]*persistConn
altProto map[string]RoundTripper // nil or map of URI scheme => RoundTripper
}
func (t *Transport) CloseIdleConnections() {
t.lk.Lock()
defer t.lk.Unlock()
if t.idleConn == nil {
return
}
for _, conns := range t.idleConn {
for _, pconn := range conns {
pconn.close()
}
}
t.idleConn = nil
}
func (t *Transport) RegisterProtocol(scheme string, rt RoundTripper) {
if scheme == "http" || scheme == "https" {
panic("protocol " + scheme + " already registered")
}
t.lk.Lock()
defer t.lk.Unlock()
if t.altProto == nil {
t.altProto = make(map[string]RoundTripper)
}
if _, exists := t.altProto[scheme]; exists {
panic("protocol " + scheme + " already registered")
}
t.altProto[scheme] = rt
}
在這個例子中，idleConn是存盤了空閑的連接，altProto是存盤了協議的處理器，CloseIdleConnections方法是關閉所有空閑的連接，RegisterProtocol是用于注冊協議處理的，
盡管ideConn和altProto這兩部分資料并沒有任何關聯，但是卻是使用同一個Mutex來保護的，這樣子當呼叫RegisterProtocol方法時，便無法呼叫CloseIdleConnections方法，這會導致競爭過多，從而影響性能，
因此，為了提高并發性能，應該將 Mutex 的鎖粒度盡量縮小，只保護需要保護的資料，
現代版本的 net/http 中已經對 Transport 進行了改進，分別使用了不同的 mutex 來保護 idleConn 和 altProto，以提高性能和代碼的可維護性，
type Transport struct {
idleMu sync.Mutex
idleConn map[connectMethodKey][]*persistConn // most recently used at end
altMu sync.Mutex // guards changing altProto only
altProto atomic.Value // of nil or map[string]RoundTripper, key is URI scheme
}
4.2 Mutex嵌入結構體中位置放置建議
將 Mutex 嵌入到結構體中，如果只需要保護其中一些資料，可以將 Mutex 放在需要控制的欄位上面，然后使用空格將被保護欄位和其他欄位進行分隔，這樣可以實作更細粒度的鎖定，也能更清晰地表達每個欄位需要被互斥保護的意圖，代碼更易于維護和理解，下面舉一些實際的例子:
Server結構體中reqLock是用來保護freeReq欄位，respLock用來保護freeResp欄位，都是將mutex放在被保護欄位的上面
//net/rpc server.go
type Server struct {
serviceMap sync.Map // map[string]*service
reqLock sync.Mutex // protects freeReq
freeReq *Request
respLock sync.Mutex // protects freeResp
freeResp *Response
}
在Transport結構體中，idleMu鎖會保護closeIdle等一系列欄位，此時將鎖放在被保護欄位的最上面，然后用空格將被idleMu鎖保護的欄位和其他欄位分隔開來， 實作更細粒度的鎖定，也能更清晰地表達每個欄位需要被互斥保護的意圖，
// net/http transport.go
type Transport struct {
idleMu sync.Mutex
closeIdle bool // user has requested to close all idle conns
idleConn map[connectMethodKey][]*persistConn // most recently used at end
idleConnWait map[connectMethodKey]wantConnQueue // waiting getConns
idleLRU connLRU
reqMu sync.Mutex
reqCanceler map[cancelKey]func(error)
altMu sync.Mutex // guards changing altProto only
altProto atomic.Value // of nil or map[string]RoundTripper, key is URI scheme
connsPerHostMu sync.Mutex
connsPerHost map[connectMethodKey]int
connsPerHostWait map[connectMethodKey]wantConnQueue // waiting getConns
}
4.3 盡量減小鎖的作用范圍
在一個代碼段里，盡量減小鎖的作用范圍可以提高并發性能，減少鎖的等待時間，從而減少系統資源的浪費，
鎖的作用范圍越大，那么就有越多的代碼需要等待鎖，這樣就會降低并發性能，因此，在撰寫代碼時，應該盡可能減小鎖的作用范圍，只在需要保護的臨界區內加鎖，
如果鎖的作用范圍是整個函式，使用 defer 陳述句來釋放鎖是一種常見的做法，可以避免忘記手動釋放鎖而導致的死鎖等問題，
func (t *Transport) CloseIdleConnections() {
t.lk.Lock()
defer t.lk.Unlock()
if t.idleConn == nil {
return
}
for _, conns := range t.idleConn {
for _, pconn := range conns {
pconn.close()
}
}
t.idleConn = nil
}
在使用鎖時，注意避免在鎖內執行長時間運行的代碼或者IO操作，因為這樣會阻塞鎖的使用，導致鎖的等待時間變長，如果確實需要在鎖內執行長時間運行的代碼或者IO操作，可以考慮將鎖釋放，讓其他代碼先執行，等待操作完成后再重新獲取鎖, 比如下面代碼示例
// net/http/httputil persist.go
func (cc *ClientConn) Read(req *http.Request) (resp *http.Response, err error) {
// Retrieve the pipeline ID of this request/response pair
cc.mu.Lock()
id, ok := cc.pipereq[req]
delete(cc.pipereq, req)
if !ok {
cc.mu.Unlock()
return nil, ErrPipeline
}
cc.mu.Unlock()
// xxx 省略掉一些中間邏輯
// 從http連接中讀取http回應資料, 這個IO操作,先解鎖
resp, err = http.ReadResponse(r, req)
// 網路IO操作結束,再繼續讀取
cc.mu.Lock()
defer cc.mu.Unlock()
if err != nil {
cc.re = err
return resp, err
}
cc.lastbody = resp.Body
cc.nread++
if resp.Close {
cc.re = ErrPersistEOF // don't send any more requests
return resp, cc.re
}
return resp, err
}
5.總結
在并發編程中，Mutex是一種常見的同步機制，用來保護共享資源，為了提高并發性能，我們需要盡可能縮小Mutex的鎖粒度，只保護需要保護的資料，同時在一個代碼段里，盡量減小鎖的作用范圍，如果鎖的作用范圍是整個函式，可以使用defer來在函式退出時解鎖，當Mutex嵌入到結構體中時，我們可以將Mutex放到要控制的欄位上面，并使用空格將欄位進行分隔，以便只保護需要保護的資料，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/546968.html
標籤：其他
上一篇：Java并發小結02