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

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不是併發安全的
			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,count) //count的值為50000
	fmt.Println("exit")
}

執行結果：

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

補充：golang 基於共享變數的併發

併發定義：當我們沒有辦法自信地確認一個事件是在另一個事件的前面或者後面發生的話，就說明x和y這兩個事件是併發的。

併發安全：如果其所有可訪問的方法和操作都是併發安全的話，那麼型別便是併發安全的。

競爭條件：程式在多個goroutine交叉執行操作時，沒有給出正確的結果。

只要有

兩個goroutine併發訪問

同一變數，且至

少其中的一個是寫操作的時候就會發生資料競爭。

資料競爭會在兩個以上的goroutine併發訪問相同的變數且至少其中一個為寫操作時發生。

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

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

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

現在我們來講第三種情況具體操作

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來實現上面的功能，那就是：

互斥鎖 sync.Mutex

互斥鎖：保證共享變數不會被併發訪問。

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之間的程式碼段中的內容goroutine可以隨便讀取或者修改，這個程式碼段叫做臨界區。

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

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

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

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

最後我們來講下記憶體同步的問題

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 執行循序卻是毫無規律

在現代計算機中可能會有一堆處理器，每一個都會有其本地快取(local cache)。為了效率，對記憶體的寫入一般會在每一個處理器中緩衝，並在必要時一起flush到主存。這種情況下這些資料可能會以與當初goroutine寫入順序不同的順序被提交到主存。導致程式執行串行了，又同時序列的程式碼訪問了共享變數，儘管goroutine A中一定需要觀察到x=1執行成功之後才會去讀取y，但它沒法確保自己觀察得到goroutine B中對y的寫入，所以A還可能會打印出y的一箇舊版的值。

有兩種方法解決：

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

2.用互斥條件訪問

以上為個人經驗，希望能給大家一個參考，也希望大家多多支援我們。如有錯誤或未考慮完全的地方，望不吝賜教。