如何使用Mutex確保併發程式的正確性

来源:https://www.cnblogs.com/chenjiazhan/archive/2023/03/15/17220186.html
-Advertisement-
Play Games

實現SpringBoot底層機制 Tomcat底層啟動分析+Spring容器初始化+Tomcat關聯Spring容器 1.任務1-創建Tomcat，並啟動 （1）創建一個Maven項目，修改pom.xml文件：我們需要自己創建Tomcat對象，因此在引入的場景啟動器中排除SpringBoot內嵌的T ...


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放到要控制的欄位上面，並使用空格將欄位進行分隔，以便只保護需要保護的數據。


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • python策略模式場景
    觀察者模式 介紹 觀察者模式是極其重要的一個設計模式，在許多框架都使用了，以及實際開發中也會用到。 定義對象之間的一種一對多的依賴關係，使得每當一個對象的狀態發生變化時，其相關的依賴對象都可以得到通知並被自動更新。主要用於多個不同的對象對一個對象的某個方法會做出不同的反應！ 以不同觀察者從同一個天氣 ...
  • 讀Java性能權威指南（第2版）筆記18_垃圾回收E
    1. 回收 1.1. 找到不使用的對象 1.2. 釋放它們的記憶體 1.3. 壓縮堆 1.4. 合在一起稱為回收 2. Throughput回收器 2.1. 工作細節比較簡單 2.1.1. 可以在同一個GC周期內完成回收 2.1.2. 在單次操作過程中回收新生代或老年代 2.2. Minor GC 2 ...
  • Bokeh 環境設置
    背景 業務系統開發時，你是否踩過這樣的坑： 業務說列表篩選姓名精準查詢查不到人？ 導入數據時，明明看起來一樣的ID卻匹配不到DB里的數據？ 看起來一樣的內容，SQL Group By 時出現好幾行？ …… DEBUG後發現，原來要麼時用戶傳入或者導入的數據里有個空格，要麼是資料庫里不知道什麼時候已經 ...
  • springboot+vue學習筆記
    P1 環境搭建 包括java,idea,maven配置,以及在idea中配置maven。 註：在files->New Project Settings中配置maven路徑，jdk版本1.8，不然重啟會失效 P2 創建springboot項目，熱部署 1、創建springboot項目時type選Mav ...
  • Python判斷列表裡是否有重覆元素的三種方法
    一、用set方法去重後與原列表長度比較 set會生成一個元素無序且不重覆的可迭代對象，也就是我們常說的去重set會生成一個元素無序且不重覆的可迭代對象，也就是我們常說的去重 lst = [1,3,5,3,4,4,2,9,6,7] set_lst=set(lst) if len(set_lst)==l ...
  • 基於 SpringBoot+vue的地方美食系統，可作為畢業設計
    1 簡介 這個項目是基於 SpringBoot和 Vue 開發的地方美食系統，包括系統功能模塊，管理員功能模塊，用戶管理模塊，功能齊全，可以作為畢業設計，課程設計等。源碼下載下來，進行一些簡單的部署，就可以使用，都有對應的教程。 2 技術棧 開發語言：Java 框架：springboot JDK版本 ...
  • Python+ChatGPT實戰之進行游戲運營數據分析
    最近ChatGPT蠻火的，今天試著讓ta寫了一篇數據分析實戰案例，大家來評價一下！ 一、數據 您的團隊已經為您提供了一些游戲數據，包括玩家的行為和收入情況。以下是數據的一些特征： user_id: 玩家ID date: 游戲日期 level: 玩家達到的游戲等級 revenue: 玩家在游戲中花費的 ...
  • 【開源免費】使用Spring Boot和Html實現ChatGPT，1：億還原，將就看
    highlight: a11y-dark 簡介 前段時間寫了一個Chatgpt的Java版SDK開源地址：chatgpt-java歡迎使用。但由於原來OpenAI 並沒有支持官網的chatgpt模型，所以使用起來相對沒有官網那麼智能完善，所以就沒有寫出一個demo項目，只開源了Open AI的SDK ...
一周排行
    -Advertisement-
    Play Games
  • 6.swagger完善：界面顯示註釋+多版本控制
    周末，寫點簡單的水一下。 新版本的vs創建項目的時候可以選擇自帶一個swagger。然而這隻是基本的swagger功能。 幾個介面無所謂啦，隨著介面越來越多，就這麼丟給你，一時間也會懵逼，所以這篇文章要做的有兩個功能。 給swagger文檔添加註釋 給swagger添加切換“版本”的功能(也可以理解 ...
  • 攔截|篡改|偽造.NET類庫中不限於public的類和方法
    大家好，我是沙漠盡頭的狼。 本文首發於Dotnet9，介紹使用Lib.Harmony庫攔截第三方.NET庫方法，達到不修改其源碼並能實現修改方法邏輯、預期行為的效果，並且不限於只攔截public訪問修飾的類及方法，行文目錄： 什麼是方法攔截？ 示常式序攔截 非public方法怎麼攔截？ 總結 1. ...
  • async/await 致WPF卡死問題
    問題代碼： xmal：一個按鈕+一個顯示框 1 <Button Width="100" Height="50" Margin="10" Click="Button_Click">test</Button> 2 <TextBox x:Name="display" Width="300" Height= ...
  • Linux下Java項目部署
    前置條件 ​ 阿裡雲伺服器一臺（可在購買伺服器時勾選安裝寶塔選項，免去後面的寶塔安裝） ​ 設置阿裡雲伺服器密碼並登陸伺服器 ​ 以下操作均在伺服器Linux中進行(使用遠程連接工具登錄) 寶塔登錄 登錄阿裡雲伺服器在Linux命令行中輸入bt，查看寶塔信息 ​ 根據寶塔信息提供的網站登陸寶塔服務( ...
  • 7.4 通過API枚舉進程許可權
    GetTokenInformation 用於檢索進程或線程的令牌(Token)信息。Token是一個數據結構，其包含有關進程或線程的安全上下文，代表當前用戶或服務的安全標識符和許可權信息。GetTokenInformation函數也可以用來獲取這些安全信息，通常用於在運行時檢查某個進程或線程的許可權或安... ...
  • 【matplotlib基礎】--3D圖形
    matplotlib 在1.0版本之前其實是不支持3D圖形繪製的。 後來的版本中，matplotlib加入了3D圖形的支持，不僅僅是為了使數據的展示更加生動和有趣。更重要的是，由於多了一個維度，擴展了其展示數據分佈和關係的能力，可以一次從三個維度來比較數據。 下麵介紹在matplotlib中繪製各類 ...
  • Flutter/Dart第01天：Dart安裝和初體驗
    編寫一個App就能編譯發佈到iOS、Android和Web等各大平臺的跨平臺技術，各大廠商一直都有研究和發佈對應技術產品，目前最熱門的莫過於Flutter框架了。而Dart作為其唯一的編程語言，今天我們開始來體驗一下…… ...
  • 實現簡單線程池
    實現基本的線程池 前提：我們要實現的線程池有如下功能： 基本的線程池模型 能提交和運行任務 能正常關閉線程池 線程的拒絕策略 線程池擴容 縮容線程池 代碼地址： 1、線程池的介紹？ 線程池是什麼？ 線程池是一種利用池化技術來管理線程的一種技術。 當沒有線程池的時候，我們如何創建線程？ 繼承Threa ...
  • 基於FPGA 的SDRAM控制器
    SDRAM基本信息 儲存能力計算 4X16X4=256（Mbit），註意不是MByte SDRAM控制 sdram包含兩個部分：sdram_ctrl、fifo_ctrl。 sdram_ctrl：其頂層為SDRAM的控制模塊內部實例化了5個模塊，有初始化、自刷新、寫和讀模塊，還有一個仲裁模塊對這四個不 ...
  • 快速搭建雲原生開發環境（k8s+pv+prometheus+grafana）
    歡迎訪問我的GitHub 這裡分類和彙總了欣宸的全部原創(含配套源碼)：https://github.com/zq2599/blog_demos 本篇概覽 欣宸正在為接下新的Java雲原生實戰系列原創做準備，既然是實戰，少不了一套雲原生環境，以下內容是必不可少的： linux操作系統 kuberne ...
所有分類