Go語言互斥鎖與讀寫鎖實例分析

這篇“Go語言互斥鎖與讀寫鎖實例分析”文章的知識點大部分人都不太理解，所以小編給大家總結了以下內容，內容詳細，步驟清晰，具有一定的借鑒價值，希望大家閱讀完這篇文章能有所收獲，下面我們一起來看看這篇“Go語言互斥鎖與讀寫鎖實例分析”文章吧。

前言：

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

一、互斥鎖是什么？

1.概念

互斥鎖是為了并發的安全,在多個goroutine共同工作的時候,對于共享的數據十分不安全寫入時容易因為競爭造成數據不必要的丟失?；コ怄i一般加在共享數據修改的地方。

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語言互斥鎖與讀寫鎖實例分析”這篇文章的內容，相信大家都有了一定的了解，希望小編分享的內容對大家有幫助，若想了解更多相關的知識內容，請關注億速云行業資訊頻道。