詳解Go并發(fā)編程時如何避免發(fā)生競態(tài)條件和數(shù)據(jù)競爭

第詳解Go并發(fā)編程時如何避免發(fā)生競態(tài)條件和數(shù)據(jù)競爭目錄會發(fā)生競態(tài)條件和數(shù)據(jù)競爭的場景有哪些避坑辦法實戰(zhàn)場景1.互斥鎖2.讀寫鎖3.原子操作4.通道5.WaitGroup6.Context

會發(fā)生競態(tài)條件和數(shù)據(jù)競爭的場景有哪些

多個goroutine對同一變量進行讀寫操作。例如，多個goroutine同時對一個計數(shù)器變量進行增加操作。多個goroutine同時對同一數(shù)組、切片或映射進行讀寫操作。例如，多個goroutine同時對一個切片進行添加或刪除元素的操作。多個goroutine同時對同一文件進行讀寫操作。例如，多個goroutine同時向同一個文件中寫入數(shù)據(jù)。多個goroutine同時對同一網(wǎng)絡(luò)連接進行讀寫操作。例如，多個goroutine同時向同一個TCP連接中寫入數(shù)據(jù)。多個goroutine同時對同一通道進行讀寫操作。例如，多個goroutine同時向同一個無緩沖通道中發(fā)送數(shù)據(jù)或接收數(shù)據(jù)。

所以，我們要明白的一點是：只要多個goroutine并發(fā)訪問了共享資源，就有可能出現(xiàn)競態(tài)條件和數(shù)據(jù)競爭。

避坑辦法

現(xiàn)在，我們已經(jīng)知道了。在編寫并發(fā)程序時，如果不謹慎，沒有考慮清楚共享資源的訪問方式和同步機制，那么就會發(fā)生競態(tài)條件和數(shù)據(jù)競爭這些問題，那么如何避免踩坑？避免發(fā)生競態(tài)條件和數(shù)據(jù)競爭的辦法有哪些？請看下面：

互斥鎖：使用sync包中的Mutex或者RWMutex，通過對共享資源加鎖來保證同一時間只有一個goroutine訪問。讀寫鎖：使用sync包中的RWMutex，通過讀寫鎖的機制來允許多個goroutine同時讀取共享資源，但是只允許一個goroutine寫入共享資源。原子操作：使用sync/atomic包中提供的原子操作，可以對共享變量進行原子操作，從而保證不會出現(xiàn)競態(tài)條件和數(shù)據(jù)競爭。通道：使用Go語言中的通道機制，可以將數(shù)據(jù)通過通道傳遞，從而避免直接對共享資源的訪問。WaitGroup：使用sync包中的WaitGroup，可以等待多個goroutine完成后再繼續(xù)執(zhí)行，從而保證多個goroutine之間的順序性。Context：使用context包中的Context，可以傳遞上下文信息并控制多個goroutine的生命周期，從而避免出現(xiàn)因為某個goroutine阻塞導(dǎo)致整個程序阻塞的情況。

實戰(zhàn)場景

1.互斥鎖

比如在一個Web服務(wù)器中，多個goroutine需要同時訪問同一個全局計數(shù)器的變量，達到記錄網(wǎng)站訪問量的目的。

在這種情況下，如果沒有對訪問計數(shù)器的訪問進行同步和保護，就會出現(xiàn)競態(tài)條件和數(shù)據(jù)競爭的問題。假設(shè)有兩個goroutineA和B，它們同時讀取計數(shù)器變量的值為N，然后都增加了1并把結(jié)果寫回計數(shù)器，那么最終的計數(shù)器值只會增加1而不是2，這就是一個競態(tài)條件。

為了解決這個問題，可以使用鎖等機制來保證訪問計數(shù)器的同步和互斥。在Go中，可以使用互斥鎖（sync.Mutex）來保護共享資源。當一個goroutine需要訪問共享資源時，它需要先獲取鎖，然后訪問資源并完成操作，最后釋放鎖。這樣就可以保證每次只有一個goroutine能夠訪問共享資源，從而避免競態(tài)條件和數(shù)據(jù)競爭問題。

看下面的代碼：

packagemain

import(

"fmt"

"sync"

varcountint

varmutexsync.Mutex

funcmain(){

varwgsync.WaitGroup

//啟動10個goroutine并發(fā)增加計數(shù)器的值

fori:=0;ii++{

wg.Add(1)

gofunc(){

//獲取鎖

mutex.Lock()

//訪問計數(shù)器并增加值

count++

//釋放鎖

mutex.Unlock()

wg.Done()

//等待所有g(shù)oroutine執(zhí)行完畢

wg.Wait()

//輸出計數(shù)器的最終值

fmt.Println(count)

}

在上面的代碼中，使用了互斥鎖來保護計數(shù)器變量的訪問。每個goroutine在訪問計數(shù)器變量之前先獲取鎖，然后進行計數(shù)器的增加操作，最后釋放鎖。這樣就可以保證計數(shù)器變量的一致性和正確性，避免競態(tài)條件和數(shù)據(jù)競爭問題。

具體的思路是，啟動每個goroutine時調(diào)用wg.Add(1)來增加等待組的計數(shù)器。然后，在所有g(shù)oroutine執(zhí)行完畢后，調(diào)用wg.Wait()來等待它們完成。最后，輸出計數(shù)器的最終值。

請注意，這個假設(shè)的場景和這個代碼示例，僅僅只是是為了演示如何使用互斥鎖來保護共享資源，實際情況可能更加復(fù)雜。例如，在實際的運維開發(fā)中，如果使用鎖的次數(shù)過多，可能會影響程序的性能。因此，在實際開發(fā)中，還需要根據(jù)具體情況選擇合適的同步機制來保證并發(fā)程序的正確性和性能。

2.讀寫鎖

下面是一個使用sync包中的RWMutex實現(xiàn)讀寫鎖的代碼案例：

packagemain

import(

"fmt"

"sync"

"time"

var(

countint

rwLocksync.RWMutex

funcreadData(){

//讀取共享數(shù)據(jù)，獲取讀鎖

rwLock.RLock()

deferrwLock.RUnlock()

fmt.Println("readingdata...")

time.Sleep(1*time.Second)

fmt.Printf("datais%d\n",count)

funcwriteData(nint){

//寫入共享數(shù)據(jù)，獲取寫鎖

rwLock.Lock()

deferrwLock.Unlock()

fmt.Println("writingdata...")

time.Sleep(1*time.Second)

count=n

fmt.Printf("datais%d\n",count)

funcmain(){

//啟動5個讀取協(xié)程

fori:=0;ii++{

goreadData()

//啟動2個寫入?yún)f(xié)程

fori:=0;ii++{

gowriteData(i+1)

//等待所有協(xié)程結(jié)束

time.Sleep(5*time.Second)

}

在這個示例中，有5個讀取協(xié)程和2個寫入?yún)f(xié)程，它們都會訪問一個共享的變量count。讀取協(xié)程使用RLock()方法獲取讀鎖，寫入?yún)f(xié)程使用Lock()方法獲取寫鎖。通過讀寫鎖的機制，多個讀取協(xié)程可以同時讀取共享數(shù)據(jù)，而寫入?yún)f(xié)程則會等待讀取協(xié)程全部結(jié)束后才能執(zhí)行，從而避免了讀取協(xié)程在寫入?yún)f(xié)程執(zhí)行過程中讀取到臟數(shù)據(jù)的問題。

3.原子操作

下面是一個使用sync/atomic包中提供的原子操作實現(xiàn)并發(fā)安全的計數(shù)器的代碼案例：

packagemain

import(

"fmt"

"sync/atomic"

"time"

funcmain(){

varcounterint64

//啟動10個協(xié)程對計數(shù)器進行增量操作

fori:=0;ii++{

gofunc(){

forj:=0;j100;j++{

atomic.AddInt64(counter,1)

//等待所有協(xié)程結(jié)束

time.Sleep(time.Second)

//輸出計數(shù)器的值

fmt.Printf("counter:%d\n",atomic.LoadInt64(counter))

}

在這個示例中，有10個協(xié)程并發(fā)地對計數(shù)器進行增量操作。由于多個協(xié)程同時對計數(shù)器進行操作，如果不使用同步機制，就會出現(xiàn)競態(tài)條件和數(shù)據(jù)競爭。為了保證程序的正確性和健壯性，使用了sync/atomic包中提供的原子操作，通過AddInt64()方法對計數(shù)器進行原子加操作，保證了計數(shù)器的并發(fā)安全。最后使用LoadInt64()方法獲取計數(shù)器的值并輸出。

4.通道

下面是一個使用通道機制實現(xiàn)并發(fā)安全的計數(shù)器的代碼案例：

packagemain

import(

"fmt"

"sync"

funcmain(){

varcounterint

//創(chuàng)建一個有緩沖的通道，容量為10

ch:=make(chanint,10)

//創(chuàng)建一個等待組，用于等待所有協(xié)程完成

varwgsync.WaitGroup

wg.Add(10)

//啟動10個協(xié)程對計數(shù)器進行增量操作

fori:=0;ii++{

gofunc(){

forj:=0;jj++{

//將增量操作發(fā)送到通道中

ch-1

//任務(wù)完成，向等待組發(fā)送信號

wg.Done()

//等待所有協(xié)程完成

wg.Wait()

//從通道中接收增量操作并累加到計數(shù)器中

fori:=0;i100;i++{

counter+=-ch

//輸出計數(shù)器的值

fmt.Printf("counter:%d\n",counter)

}

在這個示例中，有10個協(xié)程并發(fā)地對計數(shù)器進行增量操作。為了避免直接對共享資源的訪問，使用了一個容量為10的有緩沖通道，將增量操作通過通道傳遞，然后在主協(xié)程中從通道中接收增量操作并累加到計數(shù)器中。在協(xié)程中使用了等待組等待所有協(xié)程完成任務(wù)，保證了程序的正確性和健壯性。最后輸出計數(shù)器的值。

5.WaitGroup

下面是一個使用sync.WaitGroup等待多個Goroutine完成后再繼續(xù)執(zhí)行的代碼案例：

packagemain

import(

"fmt"

"sync"

funcmain(){

varwgsync.WaitGroup

fori:=1;ii++{

wg.Add(1)//計數(shù)器加1

gofunc(iint){

deferwg.Done()//完成時計數(shù)器減1

fmt.Printf("goroutine%disrunning\n",i)

}(i)

wg.Wait()//等待所有Goroutine完成

fmt.Println("allgoroutineshavecompleted")

}

在這個示例中，有3個Goroutine并發(fā)執(zhí)行，使用wg.Add(1)將計數(shù)器加1，表示有一個Goroutine需要等待。在每個Goroutine中使用deferwg.Done()表示任務(wù)完成，計數(shù)器減1。最后使用wg.Wait()等待所有Goroutine完成任務(wù)，然后輸出allgoroutineshavecompleted。

6.Context

下面是一個使用context.Context控制多個Goroutine的生命周期的代碼案例：

packagemain

import(

"context"

"fmt"

"time"

funcworker(ctxcontext.Context,idint,wg*sync.WaitGroup){

deferwg.Done()

fmt.Printf("Worker%dstarted\n",id)

for{

select{

case-ctx.Done():

fmt.Printf("Worker%dstopped\n",id)

return

default:

fmt.Printf("Worker%disrunning\n",id)

time.Sleep(time.Second)

funcmain(){

ctx,cancel:=context.WithCancel(context.Background())

varwgsync.WaitGroup

fori:=1;ii++{

wg.Add(1)

goworker(ctx,i,wg)

time.Sleep(3*time.Second)

cancel()

wg.Wait()

fmt.Println("Allworke