Go語言線程安全之互斥鎖與讀寫鎖

Posted on by

前言：

單個線程時數據操作的隻有一個線程,數據的修改也隻有一個線程參與，數據相對來說是安全的,多線程時對數據操作的不止一個線程,所以同時對數據進行修改的時候難免紊亂

一、互斥鎖是什麼？

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語言互斥鎖與讀寫鎖內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：