Go語言執行緒安全之互斥鎖與讀寫鎖

2022-02-25 19:01:22

一、互斥鎖是什麼？

1.概念

互斥鎖是為了並行的安全,在多個goroutine共同工作的時候,對於共用的資料十分不安全寫入時容易因為競爭造成資料不必要的丟失。互斥鎖一般加在共用資料修改的地方。

2.未加鎖

執行緒不安全,操作的全域性變數會計算異常

package main

import (
    "fmt"
    "sync"
)

var x int = 0

var wg sync.WaitGroup

func add() {
    defer wg.Done()
    for i := 0; i < 5000; i++ {
        x++
    }
}
func main() {
    wg.Add(2)
    go add()
    go add()
    wg.Wait()
    fmt.Println(x)
}
/*
列印結果：(每次列印不一樣,正常的結果應該是10000)
    6051
    5059
    5748
    10000
*/

3.加鎖之後

執行緒安全,全域性變數計算無異常

package main

import (
    "fmt"
    "sync"
)

var x int = 0

var wg sync.WaitGroup

// 建立一個鎖物件
var lock sync.Mutex

func add() {
    defer wg.Done()
    for i := 0; i < 5000; i++ {
        //加鎖
        lock.Lock()
        x++
        //解鎖
        lock.Unlock()
    }
}
func main() {
    wg.Add(2)
    //開啟兩個執行緒
    go add()
    go add()
    wg.Wait()
    fmt.Println(x)
}
/*
列印結果：
    全為10000
*/

二、讀寫鎖【效率革命】

1.為什麼讀寫鎖效率高

使用鎖的時候，安全與效率往往需要互相轉換，對資料進行操作的時候,只會進行資料的讀與寫。而讀與讀之間可以同時進行，讀與寫之間需要保證寫的時候不去讀。此時為了提高效率就發明讀寫鎖,在讀寫鎖機制下,安全沒有絲毫降低，但效率進行了成倍的提升提升的效率在讀與寫操作次數差異越大時越明顯

2.使用方法

程式碼如下（範例）：

package main

import (
    "fmt"
    "sync"
    "time"
)

var (
    x      = 0
    rwlock sync.RWMutex
    wg     sync.WaitGroup
)

func write() {
    defer wg.Done()
    rwlock.Lock()
    x++
    rwlock.Unlock()
}

func read() {
    wg.Done()
    //開啟讀鎖
    rwlock.RLock()
    fmt.Println(x)
    //釋放讀鎖
    rwlock.RUnlock()
}
func main() {
    start := time.Now()
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go write()
    }
    // time.Sleep(time.Second)
    for i := 0; i < 10000; i++ {
        wg.Add(1)
        go read()
    }
    wg.Wait()
    fmt.Println(time.Now().Sub(start))
}

三、sync.once

1.sync.once產生背景

在多個goroutine中往往會由於執行緒不同步造成資料讀寫的衝突,特別是在進行檔案開啟物件建立的時候，可能會造成向關閉的檔案寫內容，使用未初始化的物件，或者對一個物件進行多次初始化。

2.sync.once機制概述

sync.once保證函數內的程式碼只執行一次，實現的機制是在once內部有一個標誌位,在執行程式碼的時候執行一次之後標誌位將置為1後續判斷標誌位,如果標誌位被改為1則無法再進行操縱

3.sync.once注意點

sync.Once.Do()傳進去的函數引數無參無返，一個once物件只能執行一次Do方法,向Do方法內傳多個不同的函數時只能執行第一個傳進去的，傳進去Do方法的函數無參無返,可以用函數閉包把需要的變數傳進去

4.使用方法

一般結合並行使用,旨在對通道或檔案只進行一次關閉

func f2(a <-chan int, b chan<- int) {
    for {
        x, ok := <-a
        if !ok {
            break
        }
        fmt.Println(x)
        b <- x * 10
    }
    // 確保b通道只關閉一次
    once.Do(func() {
        close(b)
    })
}

四、atomic原子包操作

原子包將指定的資料進行安全的加減交換操作；網上還有一大堆關於原子包的api感興趣的小夥伴可以自行百度,這裡就不細細闡述了

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
)

var x int64 = 0

var wg sync.WaitGroup

/*
    原子操作是將資料進行打包枷鎖,直接通過指定的函數進行相應的操作
    可以使用load讀取、store寫入、add修改、swap交換。
    // 類似於讀取一個變數、對一個變數進行賦值
*/
func addone() {
    // 沒有加鎖進行並行的話，會產生資料丟失的情況
    defer wg.Done()
    // x++

    // 不用加鎖也可以使用的行雲流水
    // 第一個引數是進行操作的資料,第二個是增加的步長
    atomic.AddInt64(&x, 1)

}
func csf() {
    // 進行比較相等則將新值替換舊值
    ok := atomic.CompareAndSwapInt64(&x, 100, 200)
    fmt.Println(ok, x)
}

func main() {
    for i := 0; i < 50000; i++ {
        wg.Add(1)
        go addone()
    }
    wg.Wait()
    fmt.Println(x)
    x = 100
    csf()
    fmt.Println(123)
}

總結：
讀寫鎖區分讀者和寫者，而互斥鎖不區分互斥鎖同一時間只允許一個執行緒存取該物件，無論讀寫；讀寫鎖同一時間內只允許一個寫者，但是允許多個讀者同時讀物件。聯絡：讀寫鎖在獲取寫鎖的時候機制類似於互斥鎖。

到此這篇關於Go語言執行緒安全之互斥鎖與讀寫鎖的文章就介紹到這了,更多相關Go語言互斥鎖與讀寫鎖內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！