淺談golang并發(fā)操作變量安全的問題

我就廢話不多說了，大家還是直接看代碼吧~

package main 
import (
	"fmt"
	"time"
	"sync"
	"sync/atomic"
)
 
func main() {
	test1()
	test2()
}
 
func test1() {
	var wg sync.WaitGroup
	count := 0
	t := time.Now()
	for i := 0 ; i  50000 ; i++ {
		wg.Add(1)
		go func(wg *sync.WaitGroup,i int) {
			count++ //count不是并發(fā)安全的
			wg.Done()
		}(wg,i)
	}
 
	wg.Wait()
	fmt.Println(time.Now().Sub(t))
	fmt.Println("count====>",count) //count的值50000
	fmt.Println("exit")
} 
 
func test2() {
	var wg sync.WaitGroup
	count := int64(0)
	t := time.Now()
	for i := 0 ; i  50000 ; i++ {
		wg.Add(1)
		go func(wg *sync.WaitGroup,i int) {
			atomic.AddInt64(count,1) //原子操作
			wg.Done()
		}(wg,i)
	}
 
	wg.Wait()
	fmt.Println(time.Now().Sub(t))
	fmt.Println("count====>",count) //count的值為50000
	fmt.Println("exit")
}

執(zhí)行結(jié)果：

18.0485ms
count====> 46621
exit
16.0418ms
count====> 50000
exit

補充：golang 基于共享變量的并發(fā)

并發(fā)定義：當(dāng)我們沒有辦法自信地確認(rèn)一個事件是在另一個事件的前面或者后面發(fā)生的話，就說明x和y這兩個事件是并發(fā)的。

并發(fā)安全：如果其所有可訪問的方法和操作都是并發(fā)安全的話，那么類型便是并發(fā)安全的。

競爭條件：程序在多個goroutine交叉執(zhí)行操作時，沒有給出正確的結(jié)果。

只要有

兩個goroutine并發(fā)訪問

同一變量，且至

少其中的一個是寫操作的時候就會發(fā)生數(shù)據(jù)競爭。

數(shù)據(jù)競爭會在兩個以上的goroutine并發(fā)訪問相同的變量且至少其中一個為寫操作時發(fā)生。

第一種：不要去寫變量，變量直接提前初始化。

第二種：多個只允許一個goroutine訪問變量，用select來監(jiān)聽操作（go的金句：不要通過共享變量來通信，通過通信（channel)來共享變量）。

第三種：允許過個goroutine訪問變量，但是同一時間只允許一個goroutine訪問。

現(xiàn)在我們來講第三種情況具體操作

golang 我們可以通過channel作為計量器，可以保證可以有多少個goroutine可以同時訪問。make(chan struct{},1)，通過寫入讀取用阻塞的方式鎖定住指定的代碼塊的訪問。

var (
sema = make(chan struct{}, 1) // a binary semaphore guarding balance
balance int
)
func Deposit(amount int) {
sema - struct{}{} // acquire token
balance = balance + amount
-sema // release token
}
func Balance() int {
sema - struct{}{} // acquire token
b := balance
-sema // release token
return b
}

可以保證同一時刻只有一個goroutine來訪問。

然而我們可以用sync包中的Mutex來實現(xiàn)上面的功能，那就是：

互斥鎖 sync.Mutex

互斥鎖：保證共享變量不會被并發(fā)訪問。

import "sync"
var (
mu sync.Mutex // guards balance
balance int
)
func Deposit(amount int) {
mu.Lock()
balance = balance + amount
mu.Unlock()
}
func Balance() int {
mu.Lock()
b := balance
mu.Unlock()
return b
}

在Lock和Unlock之間的代碼段中的內(nèi)容goroutine可以隨便讀取或者修改，這個代碼段叫做臨界區(qū)。

注意：一定要釋放鎖(Unlock)，不管任何情況，可以利用defer Mutex.Unlock()，一定要注意go里沒有重入鎖，如果遇到更小原子的操作，考慮分解成不帶鎖功能的小塊函數(shù)

接下來我們將另一種鎖：讀寫鎖sync.RWMutex

很多情況我們需要保證讀的性能，而互斥鎖會短暫的阻止其他的goroutine的運行，沒法達到很好的多并發(fā)效果（多讀單寫），這時讀寫鎖就可以很好的解決這個問題。

RLock()和RUnlock()獲取和釋放一個讀取或者共享鎖。RLock只能在臨界區(qū)共享變量沒有任何寫入操作時可用。一般來說，我們不應(yīng)該假設(shè)邏輯上的只讀函數(shù)/方法也不會去更新某一些變量。如果沒法確定，那么久使用互斥鎖（Mutex）

最后我們來講下內(nèi)存同步的問題

var x, y int
go func() {
x = 1 // A1
fmt.Print("y:", y, " ") // A2
}()
go func() {
y = 1 // B1
fmt.Print("x:", x, " ") // B2
}()

上面的例子：A1、A2、B1、B2 執(zhí)行循序卻是毫無規(guī)律

在現(xiàn)代計算機中可能會有一堆處理器，每一個都會有其本地緩存(local cache)。為了效率，對內(nèi)存的寫入一般會在每一個處理器中緩沖，并在必要時一起flush到主存。這種情況下這些數(shù)據(jù)可能會以與當(dāng)初goroutine寫入順序不同的順序被提交到主存。導(dǎo)致程序運行串行了，又同時串行的代碼訪問了共享變量，盡管goroutine A中一定需要觀察到x=1執(zhí)行成功之后才會去讀取y，但它沒法確保自己觀察得到goroutine B中對y的寫入，所以A還可能會打印出y的一個舊版的值。

有兩種方法解決：

1.變量限定在goroutine中使用，不訪問共享變量

2.用互斥條件訪問

以上為個人經(jīng)驗，希望能給大家一個參考，也希望大家多多支持腳本之家。如有錯誤或未考慮完全的地方，望不吝賜教。