关于golang:并发安全Sync包的使用

有时候在Go代码中可能会存在多个goroutine同时操作一个资源（临界区），这种状况会产生竞态问题（数据竞态）。Sync包次要实现了并发工作同步WaitGroup的几种办法和并发平安的互斥锁和读写锁办法，还实现了比拟非凡的两个办法，一个是放弃只执行一次的Once办法和线程平安的Map。

sync.WaitGroup(同步期待)

sync.WaitGroup外部保护着一个计数器Add()，计数器的值能够减少和缩小。例如当咱们启动了N 个并发工作时，就将计数器值减少N。每个工作实现时通过调用Done()办法将计数器减1，底层为Add(-1)。通过调用Wait()来期待并发工作执行完，当计数器值为0时，示意所有并发工作曾经实现。

var x int64var wg sync.WaitGroupfunc add() {    for i := 0; i < 5000; i++ {        x = x + 1 //数据竞争    }    wg.Done()}func main() {    wg.Add(2)    go add()    go add()    wg.Wait()    fmt.Println(x)}

下面的代码中咱们开启了两个goroutine去累加变量x的值，这两个goroutine在拜访和批改x变量的时候就会存在数据竞争，导致最初的后果与期待的不符。

sync.Mutex(互斥锁)

互斥锁是一种罕用的管制共享资源拜访的办法，它可能保障同时只有一个goroutine能够访问共享资源。Go语言中应用sync包的Mutex类型来实现互斥锁。 应用互斥锁来修复下面代码的问题：

var x int64var wg sync.WaitGroupvar lock sync.Mutexfunc add() {    for i := 0; i < 5000; i++ {        lock.Lock() // 加锁        x = x + 1        lock.Unlock() // 解锁    }    wg.Done()}func main() {    wg.Add(2)    go add()    go add()    wg.Wait()    fmt.Println(x)}

应用互斥锁可能保障同一时间有且只有一个goroutine进入临界区，其余的goroutine则在期待锁；当互斥锁开释后，期待的goroutine才能够获取锁进入临界区，多个goroutine同时期待一个锁时，唤醒的策略是随机的。

sync.RWMutex(读写互斥锁)

互斥锁是齐全互斥的，然而有很多理论的场景下是读多写少的，当咱们并发的去读取一个资源不波及资源批改的时候是没有必要加锁的，这种场景下应用读写锁是更好的一种抉择。读写锁在Go语言中应用sync包中的RWMutex类型。

读写锁分为两种：读锁和写锁。当一个goroutine获取读锁之后，其余的goroutine如果是获取读锁会持续取得锁，如果是获取写锁就会期待；当一个goroutine获取写锁之后，其余的goroutine无论是获取读锁还是写锁都会期待。

读写锁示例：

var (    x      int64    wg     sync.WaitGroup    lock   sync.Mutex    rwlock sync.RWMutex)func write() {    // lock.Lock()   // 加互斥锁    rwlock.Lock() // 加写锁    x = x + 1    time.Sleep(10 * time.Millisecond) // 假如读操作耗时10毫秒    rwlock.Unlock()                   // 解写锁    // lock.Unlock()                     // 解互斥锁    wg.Done()}func read() {    // lock.Lock()                  // 加互斥锁    rwlock.RLock()               // 加读锁    time.Sleep(time.Millisecond) // 假如读操作耗时1毫秒    rwlock.RUnlock()             // 解读锁    // lock.Unlock()                // 解互斥锁    wg.Done()}func main() {    start := time.Now()    for i := 0; i < 10; i++ {        wg.Add(1)        go write()    }    for i := 0; i < 1000; i++ {        wg.Add(1)        go read()    }    wg.Wait()    end := time.Now()    fmt.Println(end.Sub(start))}

须要留神的是读写锁非常适合读多写少的场景，如果读和写的操作差异不大，读写锁的劣势就施展不进去。

sync.Once(单例)

说在后面的话：这是一个进阶知识点。

在编程的很多场景下咱们须要确保某些操作在高并发的场景下只执行一次，例如只加载一次配置文件、只敞开一次通道等。

Go语言中的sync包中提供了一个针对只执行一次场景的解决方案–sync.Once。

sync.Once只有一个Do办法，其签名如下：

func (o *Once) Do(f func()) {}

留神：如果要执行的函数f须要传递参数就须要搭配闭包来应用。

sync.Map(线程平安map)

Go语言中内置的map不是并发平安的。请看上面的示例：

var m = make(map[string]int)func get(key string) int {    return m[key]}func set(key string, value int) {    m[key] = value}func main() {    wg := sync.WaitGroup{}    for i := 0; i < 20; i++ {        wg.Add(1)        go func(n int) {            key := strconv.Itoa(n)            set(key, n)            fmt.Printf("k=:%v,v:=%v\n", key, get(key))            wg.Done()        }(i)    }    wg.Wait()}

下面的代码开启大量几个goroutine的时候可能没什么问题，当并发多了之后执行下面的代码就会报fatal error: concurrent map writes谬误。

像这种场景下就须要为map加锁来保障并发的安全性了，Go语言的sync包中提供了一个开箱即用的并发平安版map–sync.Map。开箱即用示意不必像内置的map一样应用make函数初始化就能间接应用。同时sync.Map内置了诸如Store、Load、LoadOrStore、Delete、Range等操作方法。

var m = sync.Map{}func main() {    wg := sync.WaitGroup{}    for i := 0; i < 20; i++ {        wg.Add(1)        go func(n int) {            key := strconv.Itoa(n)            m.Store(key, n)            value, _ := m.Load(key)            fmt.Printf("k=:%v,v:=%v\n", key, value)            wg.Done()        }(i)    }    wg.Wait()}

sync/atomic(原子操作)

代码中的加锁操作因为波及内核态的上下文切换会比拟耗时、代价比拟高。针对根本数据类型咱们还能够应用原子操作来保障并发平安，因为原子操作是Go语言提供的办法它在用户态就能够实现，因而性能比加锁操作更好。Go语言中原子操作由内置的规范库sync/atomic提供。

示例：

package mainimport (    "fmt"    "sync"    "sync/atomic"    "time")var x int64var l sync.Mutexvar wg sync.WaitGroup// 一般版加函数func add() {    // x = x + 1    x++ // 等价于下面的操作    wg.Done()}// 互斥锁版加函数func mutexAdd() {    l.Lock()    x++    l.Unlock()    wg.Done()}// 原子操作版加函数func atomicAdd() {    atomic.AddInt64(&x, 1)    wg.Done()}func main() {    start := time.Now()    for i := 0; i < 10000; i++ {        wg.Add(1)        //go add()       // 一般版add函数 不是并发平安的        //go mutexAdd()  // 加锁版add函数 是并发平安的，然而加锁性能开销大        go atomicAdd() // 原子操作版add函数 是并发平安，性能优于加锁版    }    wg.Wait()    end := time.Now()    fmt.Println(x)    fmt.Println(end.Sub(start))}