goland -sync/atomic原子操作小結

2022-08-09 14:01:26

1.go已經提供了鎖，為什麼還需要atomic原子操作?

1.加鎖代價比較高，耗時多，需要上下文切換。加鎖解鎖在程式碼層實現，而程式碼是執行在使用者態空間中，對底層進行操作時需要從使用者態空間切換到核心空間，再由核心操作底層資源。耗時多

2.原子操作在使用者態可以完成，效能比互斥鎖高。原子操作在cpu層面支援的，cpu可以直接操作底層資源

3.原子操作需求步驟簡單，無需加鎖解鎖步驟

2.atomic原子操作為什麼比mutex快？

1.原子操作快，是因為依賴於cpu指令，而不是依賴外部鎖。不會額外的上下文切換
2.原子操作能夠保證執行期間是連續且不會被中斷(變數不會被其他修改,mutex可能存在被其他修改的情況)

3.CAS

CAS是cpu硬體同步原語，是Compare And Swap的縮寫(比較並交換),原子操作中CAS，再sync/atomic包中,全部以ComparAndSwap開頭的函數名都是CAS操作
go中CAS操作，是借用CPU提供的原子性指令來實現。CAS操作修改共用變數時，不需要對共用變數加鎖，而是通過類似樂觀鎖的方式進行檢查，本質還是不斷的佔用CPU資源換取加鎖帶來的開銷(如上下文切換時間開銷)。

原子操作優勢：
可以在不形成臨界區和建立互斥量的情況下完成並行安全的值替換操作。這可以大大的減少同步對程式效能的損耗。

原子操作劣勢：
在被操作值被頻繁的變更的情況下，CAS操作並不那麼容易成功。因為需要對ild值進行匹配，只有匹配成功了才進行下一步的修改。

當前atmomic包有以下幾種原子操作：
Add,ComparAndSwap,Load,Store,Swap

4.互斥鎖與原子操作區別

互斥鎖目的：互斥鎖是用來保護一段邏輯的，保證並行安全。(比如運算元據庫保護)
原子操作目的：原子操作作用於一個變數的更新保護，保證並行安全(比如運算元據庫不能原子操作)

mutex底層實現：mutex由作業系統的排程器實現
原子操作底層實現：由底層硬體指令直接提供支援，這些指令在執行過程中不允許中斷，因此原子操作可以在無鎖的情況下保證並行安全，效能隨cpu的數量增多而線性擴充套件。

5.原子操作方法

5.1 atomic.AddInt32--增減

增減，操作方法的命名方式為AddXXX,保證對運算元進行原子的增減，支援的型別為int32、int64、uint32、uint64、uintptr，使用時以AddXXX就是對應的操作方法。

//加
func demo() {
	var count int32 = 0
	atomic.AddInt32(&count, 10)
	fmt.Println(count) //10
}
//減
func demo() {
	var count int32 = 0
	atomic.AddInt32(&count, -10)
	fmt.Println(count) //-10
}

鎖和原子操作對比：

//Mutex鎖
func demo1() {
	sta := time.Now().Unix()
	count := 0
	mux := sync.Mutex{}
	wg := sync.WaitGroup{}
	for i := 0; i < 10000; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for j := 0; j < 10000; j++ {
				mux.Lock()
				count++
				mux.Unlock()
			}
		}()
	}
	wg.Wait()
	fmt.Println(count) //100000000
	fmt.Println(time.Now().Unix() - sta) //10秒
}

//atomic原子操作：快2倍不止
func demo2() {
	sta := time.Now().Unix()
	wg := sync.WaitGroup{}
	var count int32 = 0
	for i := 0; i < 10000; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for j := 0; j < 10000; j++ {
				atomic.AddInt32(&count, 1)
			}
		}()
	}
	wg.Wait()
	fmt.Println(count) //100000000
	fmt.Println(time.Now().Unix() - sta) //4秒
}

5.2 CAS-atomic.CompareAndSwapInt32--比較並替換

CompareAndSwap:比較並替換,類似樂觀鎖，先比較下old值與當前值是否一致，一致則把new的值替換
操作方法的命名方式為CompareAndSwapXXX

//true
func demo3() {
	var count int32 = 0
	boo := atomic.CompareAndSwapInt32(&count, 0, 100)
	fmt.Println(count) //100
	fmt.Println(boo)   //true
}


//false
func demo3() {
	var count int32 = 0
	boo := atomic.CompareAndSwapInt32(&count, 10, 100)
	fmt.Println(count) //0
	fmt.Println(boo) //false
}

5.3 atomic.StoreInt32--寫操作

func demo3() {
	var count int32 = 0
	atomic.StoreInt32(&count, 666)
	fmt.Println(count) //666
}

5.4 atomic.LoadInt32--讀操作

func demo3() {
	var count int32 = 0
	atomic.StoreInt32(&count, 666)

	val := atomic.LoadInt32(&count)
	fmt.Println(val) //666
}

5.5 atomic.SwapInt32--直接交換

atomic.SwapInt32：直接交換，並返回交換前的值

func demo3() {
	var count int32 = 0
	old := atomic.SwapInt32(&count, 100)
	fmt.Println(old)   //0
	fmt.Println(count) //100
}

到此這篇關於goland-sync/atomic原子操作的文章就介紹到這了,更多相關goland sync/atomic原子操作內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！