sync.WaitGroup 优雅的同步执行协程
package main
import (
"fmt"
"math/rand"
"sync"
"time"
)
func f1(i int) {
defer wg.Done()
rand.Seed(time.Now().UnixNano())
time.Sleep(time.Millisecond * time.Duration(rand.Intn(3)))
fmt.Println(i)
}
var wg sync.WaitGroup
func main() {
for i := 0; i < 10; i++ {
wg.Add(1)
go f1(i)
}
wg.Wait()
}
sync.Mutex 互斥锁
package main
import (
"fmt"
"sync"
)
var x = 0
var wg sync.WaitGroup
var mu sync.Mutex
func add() {
defer wg.Done()
for i := 0; i < 500000; i++ {
//公共资源加锁
mu.Lock()
x = x + 1
//解锁
mu.Unlock()
}
}
func main() {
wg.Add(2)
go add()
go add()
wg.Wait()
fmt.Println(x)
}
sync.RWMutex 读写锁
-
基本遵循两大原则：1、获取到读锁之后可以随便读，多个goroutine同时读，但是任何goroutine都不能写；2、写的时候，啥也不能干。只能获取到写锁的那个goroutine可以写，其他的goroutine既不能读也不能写。
package main
import (
"fmt"
"sync"
"time"
)
var (
x int = 1
wg sync.WaitGroup
rw sync.RWMutex
)
func write() {
defer wg.Done()
rw.Lock()
x = x + 1
rw.Unlock()
time.Sleep(time.Millisecond)
}
func read() {
defer wg.Done()
rw.RLock()
fmt.Println(x)
rw.RUnlock()
}
func main() {
for i := 1; i < 10; i++ {
wg.Add(1)
go write()
}
time.Sleep(time.Second)
for m := 0; m < 100; m++ {
wg.Add(1)
go read()
}
wg.Wait()
}
sync.Once 保证只执行一次
package singleton
import (
"sync"
)
type singleton struct {}
var instance *singleton
var once sync.Once
func GetInstance() *singleton {
once.Do(func() {
instance = &singleton{}
})
return instance
}
sync.Map 并发安全的map数据结构(Go中内置的map是并发不安全的)
package main
import (
"fmt"
"strconv"
"sync"
)
func main() {
var m = sync.Map{}
var wg sync.WaitGroup
for i := 0; i < 40; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
str := strconv.Itoa(i)
m.Store(i, str)
v, _ := m.Load(i)
fmt.Printf("key:%v,value:%v
", i, v)
}(i)
}
wg.Wait()
}