欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

GO使用Mutex確保并發(fā)程序正確性詳解

 更新時間:2023年03月03日 11:51:49   作者:starrySky  
這篇文章主要為大家介紹了GO使用Mutex確保并發(fā)程序正確性詳解,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪

1. 簡介

本文的主要內容是介紹Go中Mutex并發(fā)原語。包含Mutex的基本使用,使用的注意事項以及一些實踐建議。

2. 基本使用

2.1 基本定義

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

2.2 使用方式

  使用Mutex的基本方法非常簡單,可以通過調用Mutex的Lock方法來獲取鎖,然后通過Unlock方法釋放鎖,示例代碼如下:

import "sync"
var mutex sync.Mutex
func main() {
  mutex.Lock()    // 獲取鎖
  // 執(zhí)行需要同步的操作
  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同時訪問的情況下會出現競態(tài)條件。但是由于沒有使用Mutex進行同步,所以會導致count的值無法正確累加,最終輸出的結果也會出現錯誤。

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

2.3.2 使用mutex解決上述問題

下面是使用Mutex進行同步控制,解決上述代碼中競態(tài)條件問題的示例:

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可以繼續(xù)訪問count變量。

通過使用Mutex進行同步控制,我們避免了競態(tài)條件的出現,確保了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")
    }()
}

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

在第一個goroutine中,我們調用了mutex.Lock()方法獲取mutex的鎖,但是沒有調用相應的Unlock方法。在第二個goroutine中,我們首先打印了一條信息,然后調用了mutex.Lock()方法嘗試獲取mutex的鎖。由于第一個goroutine沒有釋放mutex的鎖,第二個goroutine就一直阻塞在Lock方法中,一直無法執(zhí)行。

因此,在使用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,以避免競態(tài)條件的發(fā)生。

如果我們在Mutex未解鎖的情況下拷貝這個Mutex,就會導致鎖失效的問題。因為Mutex的狀態(tài)信息被拷貝了,拷貝出來的Mutex還是處于鎖定的狀態(tài)。而在函數中,當要訪問臨界區(qū)數據時,首先肯定是先調用Mutex.Lock方法加鎖,而傳入Mutex其實是處于鎖定狀態(tài)的,此時函數將永遠無法獲取到鎖。

因此,不能將已使用的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 進行了一次加鎖,然后在沒有解鎖的情況下,又進行了一次加鎖操作.

這種情況下,程序會出現死鎖,因為第二次加鎖操作已經被阻塞,等待第一次加鎖的解鎖操作,而第一次加鎖的解鎖操作也被阻塞,等待第二次加鎖的解鎖操作,導致了互相等待的局面,無法繼續(xù)執(zhí)行下去。

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 =&gt; 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是存儲了協(xié)議的處理器,CloseIdleConnections方法是關閉所有空閑的連接,RegisterProtocol是用于注冊協(xié)議處理的。

盡管ideConn和altProto這兩部分數據并沒有任何關聯(lián),但是卻是使用同一個Mutex來保護的,這樣子當調用RegisterProtocol方法時,便無法調用CloseIdleConnections方法,這會導致競爭過多,從而影響性能。

因此,為了提高并發(fā)性能,應該將 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 盡量減小鎖的作用范圍

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

鎖的作用范圍越大,那么就有越多的代碼需要等待鎖,這樣就會降低并發(fā)性能。因此,在編寫代碼時,應該盡可能減小鎖的作用范圍,只在需要保護的臨界區(qū)內加鎖。

如果鎖的作用范圍是整個函數,使用 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
}

在使用鎖時,注意避免在鎖內執(zhí)行長時間運行的代碼或者IO操作,因為這樣會阻塞鎖的使用,導致鎖的等待時間變長。如果確實需要在鎖內執(zhí)行長時間運行的代碼或者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響應數據, 這個IO操作,先解鎖
   resp, err = http.ReadResponse(r, req)
   // 網絡IO操作結束,再繼續(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.總結

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

以上就是GO使用Mutex確保并發(fā)程序正確性詳解的詳細內容,更多關于GO Mutex并發(fā)正確性的資料請關注腳本之家其它相關文章!

相關文章

  • 解決golang http重定向失效的問題

    解決golang http重定向失效的問題

    這篇文章主要介紹了解決golang http重定向失效的問題,具有很好的參考價值,希望對大家有所幫助。一起跟隨小編過來看看吧
    2020-12-12
  • go語言中json處理方式詳解

    go語言中json處理方式詳解

    這篇文章主要介紹了go語言中json處理方式,文中通過實例代碼講解的非常詳細,對大家的學習或工作有一定的幫助,感興趣的小伙伴跟著小編一起來看看吧
    2024-05-05
  • 一文帶你了解Go語言實現的并發(fā)神庫conc

    一文帶你了解Go語言實現的并發(fā)神庫conc

    前幾天逛github發(fā)現了一個有趣的并發(fā)庫-conc,這篇文章將為大家詳細介紹一下這個庫的實現,文中的示例代碼講解詳細,感興趣的可以了解一下
    2023-01-01
  • Go語言規(guī)范context?類型的key用法示例解析

    Go語言規(guī)范context?類型的key用法示例解析

    這篇文章主要為大家介紹了Go語言規(guī)范context?類型的key用法示例解析,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪
    2023-08-08
  • 使用go mod導入本地自定義包問題

    使用go mod導入本地自定義包問題

    這篇文章主要介紹了使用go mod導入本地自定義包問題,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教
    2024-07-07
  • Golang線上內存爆掉問題排查(pprof)與解決

    Golang線上內存爆掉問題排查(pprof)與解決

    這篇文章主要介紹了Golang線上內存爆掉問題排查(pprof)與解決,涉及到數據敏感,文中代碼是我模擬線上故障的一個情況,好在我們程序都有添加pprof監(jiān)控,于是直接通過go tool pprof分析,需要的朋友可以參考下
    2024-04-04
  • 使用Go重試機制代碼更可靠

    使用Go重試機制代碼更可靠

    這篇文章主要為大家介紹了使用Go重試機制的使用,使你的代碼更加可靠,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪
    2022-08-08
  • Go語言設計實現在任務欄里提醒你喝水的兔子

    Go語言設計實現在任務欄里提醒你喝水的兔子

    這篇文章主要為大家介紹了Go語言設計實現在任務欄里提醒你喝水的兔子示例詳解,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪
    2023-01-01
  • 使用Singleflight實現Golang代碼優(yōu)化

    使用Singleflight實現Golang代碼優(yōu)化

    有許多方法可以優(yōu)化代碼以提高效率,減少運行進程就是其中之一,本文我們就來學習一下如何通過使用一個Go包Singleflight來減少重復進程,從而優(yōu)化Go代碼吧
    2023-09-09
  • Go defer與time.sleep的使用與區(qū)別

    Go defer與time.sleep的使用與區(qū)別

    本文主要介紹了Go defer與time.sleep的使用與區(qū)別,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧
    2024-04-04

最新評論