1. 簡(jiǎn)介

本文的主要內(nèi)容是介紹Go中Mutex并發(fā)原語(yǔ)。包含Mutex的基本使用，使用的注意事項(xiàng)以及一些實(shí)踐建議。

2. 基本使用

2.1 基本定義

  Mutex是Go語(yǔ)言中的一種同步原語(yǔ)，全稱(chēng)為Mutual Exclusion，即互斥鎖。它可以在并發(fā)編程中實(shí)現(xiàn)對(duì)共享資源的互斥訪問(wèn)，保證同一時(shí)刻只有一個(gè)協(xié)程可以訪問(wèn)共享資源。Mutex通常用于控制對(duì)臨界區(qū)的訪問(wèn)，以避免競(jìng)態(tài)條件的出現(xiàn)。

2.2 使用方式

  使用Mutex的基本方法非常簡(jiǎn)單，可以通過(guò)調(diào)用Mutex的Lock方法來(lái)獲取鎖，然后通過(guò)Unlock方法釋放鎖，示例代碼如下：

import "sync"
var mutex sync.Mutex
func main() {
  mutex.Lock()    // 獲取鎖
  // 執(zhí)行需要同步的操作
  mutex.Unlock()  // 釋放鎖
}

2.3 使用例子

2.3.1 未使用mutex同步代碼示例

下面是一個(gè)使用goroutine訪問(wèn)共享資源，但沒(méi)有使用Mutex進(jìn)行同步的代碼示例：

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++
}

上述代碼中，我們啟動(dòng)了1000個(gè)goroutine，每個(gè)goroutine都調(diào)用add()函數(shù)將count變量的值加1。由于count變量是共享資源，因此在多個(gè)goroutine同時(shí)訪問(wèn)的情況下會(huì)出現(xiàn)競(jìng)態(tài)條件。但是由于沒(méi)有使用Mutex進(jìn)行同步，所以會(huì)導(dǎo)致count的值無(wú)法正確累加，最終輸出的結(jié)果也會(huì)出現(xiàn)錯(cuò)誤。

在這個(gè)例子中，由于多個(gè)goroutine同時(shí)訪問(wèn)count變量，而不進(jìn)行同步控制，導(dǎo)致每個(gè)goroutine都可能讀取到同樣的count值，進(jìn)行相同的累加操作。這就會(huì)導(dǎo)致最終輸出的count值不是期望的結(jié)果。如果我們使用Mutex進(jìn)行同步控制，就可以避免這種競(jìng)態(tài)條件的出現(xiàn)。

2.3.2 使用mutex解決上述問(wèn)題

下面是使用Mutex進(jìn)行同步控制，解決上述代碼中競(jìng)態(tài)條件問(wèn)題的示例：

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()
}

在上述代碼中，我們?cè)谌侄x了一個(gè)sync.Mutex類(lèi)型的變量mutex，用于進(jìn)行同步控制。在add()函數(shù)中，我們首先調(diào)用mutex.Lock()方法獲取mutex的鎖，確保只有一個(gè)goroutine可以訪問(wèn)count變量。然后進(jìn)行加1操作，最后調(diào)用mutex.Unlock()方法釋放mutex的鎖，使其他goroutine可以繼續(xù)訪問(wèn)count變量。

通過(guò)使用Mutex進(jìn)行同步控制，我們避免了競(jìng)態(tài)條件的出現(xiàn)，確保了count變量的正確累加。最終輸出的結(jié)果也符合預(yù)期。

3. 使用注意事項(xiàng)

3.1 Lock/Unlock需要成對(duì)出現(xiàn)

下面是一個(gè)沒(méi)有成對(duì)出現(xiàn)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")
    }()
}

在上述代碼中，我們創(chuàng)建了一個(gè)sync.Mutex類(lèi)型的變量mutex，然后在兩個(gè)goroutine中使用了這個(gè)mutex。

在第一個(gè)goroutine中，我們調(diào)用了mutex.Lock()方法獲取mutex的鎖，但是沒(méi)有調(diào)用相應(yīng)的Unlock方法。在第二個(gè)goroutine中，我們首先打印了一條信息，然后調(diào)用了mutex.Lock()方法嘗試獲取mutex的鎖。由于第一個(gè)goroutine沒(méi)有釋放mutex的鎖，第二個(gè)goroutine就一直阻塞在Lock方法中，一直無(wú)法執(zhí)行。

因此，在使用Mutex的過(guò)程中，一定要確保每個(gè)Lock方法都有對(duì)應(yīng)的Unlock方法，確保Mutex的正常使用。

3.2 不能對(duì)已使用的Mutex作為參數(shù)進(jìn)行傳遞

下面舉一個(gè)已使用的Mutex作為參數(shù)進(jìn)行傳遞的代碼的例子:

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")
}

當(dāng)一個(gè) mutex 被傳遞給一個(gè)函數(shù)時(shí)，預(yù)期的行為應(yīng)該是該函數(shù)在訪問(wèn)受 mutex 保護(hù)的共享資源時(shí)，能夠正確地獲取和釋放 mutex，以避免競(jìng)態(tài)條件的發(fā)生。

如果我們?cè)贛utex未解鎖的情況下拷貝這個(gè)Mutex，就會(huì)導(dǎo)致鎖失效的問(wèn)題。因?yàn)镸utex的狀態(tài)信息被拷貝了，拷貝出來(lái)的Mutex還是處于鎖定的狀態(tài)。而在函數(shù)中，當(dāng)要訪問(wèn)臨界區(qū)數(shù)據(jù)時(shí)，首先肯定是先調(diào)用Mutex.Lock方法加鎖，而傳入Mutex其實(shí)是處于鎖定狀態(tài)的，此時(shí)函數(shù)將永遠(yuǎn)無(wú)法獲取到鎖。

因此，不能將已使用的Mutex直接作為參數(shù)進(jìn)行傳遞。

3.3 不可重復(fù)調(diào)用Lock/UnLock方法

下面是一個(gè)例子，其中對(duì)同一個(gè) Mutex 進(jìn)行了重復(fù)加鎖：

package main
import (
    "fmt"
    "sync"
)
func main() {
    var mu sync.Mutex
    mu.Lock()
    fmt.Println("First Lock")
    // 重復(fù)加鎖
    mu.Lock()
    fmt.Println("Second Lock")
    mu.Unlock()
    mu.Unlock()
}

在這個(gè)例子中，我們先對(duì) Mutex 進(jìn)行了一次加鎖，然后在沒(méi)有解鎖的情況下，又進(jìn)行了一次加鎖操作.

這種情況下，程序會(huì)出現(xiàn)死鎖，因?yàn)榈诙渭渔i操作已經(jīng)被阻塞，等待第一次加鎖的解鎖操作，而第一次加鎖的解鎖操作也被阻塞，等待第二次加鎖的解鎖操作，導(dǎo)致了互相等待的局面，無(wú)法繼續(xù)執(zhí)行下去。

Mutex實(shí)際上是通過(guò)一個(gè)int32類(lèi)型的標(biāo)志位來(lái)實(shí)現(xiàn)的。當(dāng)這個(gè)標(biāo)志位為0時(shí)，表示這個(gè)Mutex當(dāng)前沒(méi)有被任何goroutine獲??；當(dāng)標(biāo)志位為1時(shí)，表示這個(gè)Mutex當(dāng)前已經(jīng)被某個(gè)goroutine獲取了。

Mutex的Lock方法實(shí)際上就是將這個(gè)標(biāo)志位從0改為1，表示獲取了鎖；Unlock方法則是將標(biāo)志位從1改為0，表示釋放了鎖。當(dāng)?shù)诙握{(diào)用Lock方法，此時(shí)標(biāo)記位為1，代表有一個(gè)goroutine持有了這個(gè)鎖，此時(shí)將會(huì)被阻塞，而持有該鎖的其實(shí)就是當(dāng)前的goroutine,此時(shí)該程序?qū)?huì)永遠(yuǎn)阻塞下去。

4. 實(shí)踐建議

4.1 Mutex鎖不要同時(shí)保護(hù)兩份不相關(guān)數(shù)據(jù)

下面是一個(gè)例子，使用Mutex同時(shí)保護(hù)兩份不相關(guān)的數(shù)據(jù)

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

在這個(gè)例子中，idleConn是存儲(chǔ)了空閑的連接，altProto是存儲(chǔ)了協(xié)議的處理器，CloseIdleConnections方法是關(guān)閉所有空閑的連接，RegisterProtocol是用于注冊(cè)協(xié)議處理的。

盡管ideConn和altProto這兩部分?jǐn)?shù)據(jù)并沒(méi)有任何關(guān)聯(lián)，但是卻是使用同一個(gè)Mutex來(lái)保護(hù)的，這樣子當(dāng)調(diào)用RegisterProtocol方法時(shí)，便無(wú)法調(diào)用CloseIdleConnections方法，這會(huì)導(dǎo)致競(jìng)爭(zhēng)過(guò)多，從而影響性能。

因此，為了提高并發(fā)性能，應(yīng)該將 Mutex 的鎖粒度盡量縮小，只保護(hù)需要保護(hù)的數(shù)據(jù)。

現(xiàn)代版本的 net/http 中已經(jīng)對(duì) Transport 進(jìn)行了改進(jìn)，分別使用了不同的 mutex 來(lái)保護(hù) idleConn 和 altProto，以提高性能和代碼的可維護(hù)性。

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嵌入結(jié)構(gòu)體中位置放置建議

將 Mutex 嵌入到結(jié)構(gòu)體中，如果只需要保護(hù)其中一些數(shù)據(jù)，可以將 Mutex 放在需要控制的字段上面，然后使用空格將被保護(hù)字段和其他字段進(jìn)行分隔。這樣可以實(shí)現(xiàn)更細(xì)粒度的鎖定，也能更清晰地表達(dá)每個(gè)字段需要被互斥保護(hù)的意圖，代碼更易于維護(hù)和理解。下面舉一些實(shí)際的例子:

Server結(jié)構(gòu)體中reqLock是用來(lái)保護(hù)freeReq字段，respLock用來(lái)保護(hù)freeResp字段，都是將mutex放在被保護(hù)字段的上面

//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結(jié)構(gòu)體中，idleMu鎖會(huì)保護(hù)closeIdle等一系列字段，此時(shí)將鎖放在被保護(hù)字段的最上面，然后用空格將被idleMu鎖保護(hù)的字段和其他字段分隔開(kāi)來(lái)。 實(shí)現(xiàn)更細(xì)粒度的鎖定，也能更清晰地表達(dá)每個(gè)字段需要被互斥保護(hù)的意圖。

// 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 盡量減小鎖的作用范圍

在一個(gè)代碼段里，盡量減小鎖的作用范圍可以提高并發(fā)性能，減少鎖的等待時(shí)間，從而減少系統(tǒng)資源的浪費(fèi)。

鎖的作用范圍越大，那么就有越多的代碼需要等待鎖，這樣就會(huì)降低并發(fā)性能。因此，在編寫(xiě)代碼時(shí)，應(yīng)該盡可能減小鎖的作用范圍，只在需要保護(hù)的臨界區(qū)內(nèi)加鎖。

如果鎖的作用范圍是整個(gè)函數(shù)，使用 defer 語(yǔ)句來(lái)釋放鎖是一種常見(jiàn)的做法，可以避免忘記手動(dòng)釋放鎖而導(dǎo)致的死鎖等問(wèn)題。

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
}

在使用鎖時(shí)，注意避免在鎖內(nèi)執(zhí)行長(zhǎng)時(shí)間運(yùn)行的代碼或者IO操作，因?yàn)檫@樣會(huì)阻塞鎖的使用，導(dǎo)致鎖的等待時(shí)間變長(zhǎng)。如果確實(shí)需要在鎖內(nèi)執(zhí)行長(zhǎng)時(shí)間運(yùn)行的代碼或者IO操作，可以考慮將鎖釋放，讓其他代碼先執(zhí)行，等待操作完成后再重新獲取鎖, 比如下面代碼示例

// 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響應(yīng)數(shù)據(jù), 這個(gè)IO操作,先解鎖
   resp, err = http.ReadResponse(r, req)
   // 網(wǎng)絡(luò)IO操作結(jié)束,再繼續(xù)讀取
   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.總結(jié)

在并發(fā)編程中，Mutex是一種常見(jiàn)的同步機(jī)制，用來(lái)保護(hù)共享資源。為了提高并發(fā)性能，我們需要盡可能縮小Mutex的鎖粒度，只保護(hù)需要保護(hù)的數(shù)據(jù)，同時(shí)在一個(gè)代碼段里，盡量減小鎖的作用范圍。如果鎖的作用范圍是整個(gè)函數(shù)，可以使用defer來(lái)在函數(shù)退出時(shí)解鎖。當(dāng)Mutex嵌入到結(jié)構(gòu)體中時(shí)，我們可以將Mutex放到要控制的字段上面，并使用空格將字段進(jìn)行分隔，以便只保護(hù)需要保護(hù)的數(shù)據(jù)。

以上就是GO使用Mutex確保并發(fā)程序正確性詳解的詳細(xì)內(nèi)容，更多關(guān)于GO Mutex并發(fā)正確性的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！

最新評(píng)論