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

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ā)定義：當我們沒有辦法自信地確認一個事件是在另一個事件的前面或者后面發(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ù)可能會以與當初goroutine寫入順序不同的順序被提交到主存。導致程序運行串行了，又同時串行的代碼訪問了共享變量，盡管goroutine A中一定需要觀察到x=1執(zhí)行成功之后才會去讀取y，但它沒法確保自己觀察得到goroutine B中對y的寫入，所以A還可能會打印出y的一個舊版的值。

有兩種方法解決：

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

2.用互斥條件訪問

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