goland的“同步”簡析

1、import（“sync”）

2、var lock sync.Mutex

互斥鎖：某一資源同時只允許一個訪問者，效率較低

3、var lock sync.RWMutex

讀寫鎖：適用於讀操作較多，寫操作較少；多個讀操作可以同時；寫操作之間互斥，同一時間只能有一個寫操作，讀寫也不能同時進行；寫操作優先於讀操作

4、檢查代碼是否存在資源競爭的指令：-race

簡潔寫法

go run -race ...xxx.go

5、demo演示

package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

//鎖
func main()  {
	//testMap1()
	//testMap2()
	//testMap3()
}
//1、不加鎖
func testMap1(){
	//初始化賦值
	var a map[int]int
	a=make(map[int]int,5)
	for i:=0;i<5;i++ {
		a[i]=i
	}
	//競爭
	for i:=0;i<2;i++{
		go func(b map[int]int) {
			//寫操作
			b[0]=rand.Intn(100)
		}(a)
	}
	//讀操作
	fmt.Println(a)
}
//2、互斥鎖
var lock1 sync.Mutex
func testMap2(){
	//初始化賦值
	var a map[int]int
	a=make(map[int]int,5)
	for i:=0;i<5;i++ {
		a[i]=i
	}
	//競爭
	for i:=0;i<2;i++{
		go func(b map[int]int) {
			//寫操作
			lock1.Lock()
			b[0]=rand.Intn(100)
			lock1.Unlock()
		}(a)
	}
	//讀操作
	lock1.Lock()
	fmt.Println(a)
	lock1.Unlock()

	time.Sleep(time.Second)
}
//3、讀寫鎖
var lock2 sync.RWMutex
func testMap3(){
	//初始化賦值
	var a map[int]int
	a=make(map[int]int,5)
	for i:=0;i<5;i++ {
		a[i]=i
	}
	//a、寫操作
	for i:=0;i<5;i++{
		go func(b map[int]int) {
			lock2.Lock()
			b[0]=rand.Intn(100)
			lock2.Unlock()
		}(a)
	}
	//b、讀操作
	for i:=0;i<100;i++{
		go func() {
			lock2.RLock()
			fmt.Println(a)
			lock2.RUnlock()
		}()
	}

	time.Sleep(5*time.Second)

}

不加鎖測試結果：

1、go run x.go

2、go run -race x.go