快捷導航

Golang安全讀寫共享變量的方式詳解

更新時間：2024年05月20日 14:47:27 作者：劉鑄緯

互斥鎖（Mutex）是一種常用的同步原語,用于防止多個協(xié)程同時訪問共享資源,這篇文章主要介紹了Golang安全讀寫共享變量的方式,需要的朋友可以參考下

1. 使用互斥鎖(Mutex)

互斥鎖（Mutex）是一種常用的同步原語，用于防止多個協(xié)程同時訪問共享資源。

package main
import (
    "fmt"
    "sync"
)
var (
    counter int
    mutex   sync.Mutex
)
func increment(wg *sync.WaitGroup) {
    defer wg.Done()
    mutex.Lock()
    counter++
    mutex.Unlock()
}
func main() {
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go increment(&wg)
    }
    wg.Wait()
    fmt.Println("Final Counter:", counter)
}

2. 使用channel

Go語言的核心理念之一就是“不通過共享內(nèi)存來通信，而是通過通信來共享內(nèi)存”。我們可以通過創(chuàng)建一個channel，然后通過發(fā)送和接收消息的方式來讀寫共享變量。這種方式在處理并發(fā)問題時非常有用，因為channel本身就提供了安全性。

package main
import (
    "fmt"
)
func increment(counter chan int, done chan bool) {
    for i := 0; i < 1000; i++ {
        value := <-counter
        value++
        counter <- value
    }
    done <- true
}
func main() {
    counter := make(chan int, 1)
    counter <- 0
    done := make(chan bool)
    for i := 0; i < 10; i++ {
        go increment(counter, done)
    }
    for i := 0; i < 10; i++ {
        <-done
    }
    fmt.Println("Final Counter:", <-counter)
}

3. 讀寫鎖(sync.RWMutex)

如果程序中的讀操作遠多于寫操作，那么使用讀寫鎖可能會比互斥鎖更有效率。讀寫鎖允許多個協(xié)程同時讀取變量，但是只允許同一時刻只有一個協(xié)程進行寫入操作。

package main
import (
    "fmt"
    "sync"
)
var (
    counter int
    rwMutex sync.RWMutex
)
func read(wg *sync.WaitGroup) {
    defer wg.Done()
    rwMutex.RLock()
    fmt.Println("Counter:", counter)
    rwMutex.RUnlock()
}
func write(wg *sync.WaitGroup) {
    defer wg.Done()
    rwMutex.Lock()
    counter++
    rwMutex.Unlock()
}
func main() {
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go read(&wg)
    }
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go write(&wg)
    }
    wg.Wait()
}

4. 原子操作(sync/atomic包)

對于一些簡單的數(shù)值或者布爾類型，我們可以使用原子操作來讀寫共享變量。

package main
import (
    "fmt"
    "sync"
    "sync/atomic"
)
var counter int64
func increment(wg *sync.WaitGroup) {
    defer wg.Done()
    atomic.AddInt64(&counter, 1)
}
func main() {
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go increment(&wg)
    }
    wg.Wait()
    fmt.Println("Final Counter:", counter)
}

5. sync.Once

如果共享變量只需要被初始化一次，可以使用sync.Once來確保初始化的并發(fā)安全性。

package main
import (
    "fmt"
    "sync"
)
var (
    once sync.Once
    initValue int
)
func initialize() {
    fmt.Println("Initializing...")
    initValue = 42
}
func doSomething() {
    once.Do(initialize)
    fmt.Println("Value:", initValue)
}
func main() {
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            doSomething()
        }()
    }
    wg.Wait()
}

最后給大家推薦一個LinuxC/C++高級架構(gòu)系統(tǒng)教程的學習資源與課程，可以幫助你有方向、更細致地學習C/C++后端開發(fā)，具體內(nèi)容請見 https://xxetb.xetslk.com/s/1o04uB

到此這篇關(guān)于Golang安全讀寫共享變量的方式的文章就介紹到這了,更多相關(guān)Golang安全讀寫共享變量內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: