这是我参与「第五届青训营」伴学笔记创作活动的第 2 天、

sync包

互斥锁互斥锁是一种常用的控制共享资源访问的方法，它能够保证同时只有一个goroutine可以访问共享资源。Go语言中使用sync包的Mutex类型来实现互斥锁。使用互斥锁来修复上面代码的问题：

package main

import (
    "fmt"
    "sync"
)

var x = 0

const N = 5000000

var wg sync.WaitGroup
var lock sync.Mutex //原子锁

func add() {
    for i := 0; i < N; i++ {
        lock.Lock()
        x = x + 1
        lock.Unlock()
    }
    wg.Done()
}
func main() {

    wg.Add(2)
    go add()
    go add()
    wg.Wait()
    fmt.Println(x)
}

互斥锁是完全互斥的，但是有很多实际的场景下是读多写少的，当我们并发的去读取一个资源不涉及资源修改的时候是没有必要加锁的，这种场景下使用读写锁是更好的一种选择。读写锁在Go语言中使用sync包中的RWMutex类型。

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

package main

import (
    "fmt"
    "sync"
    "time"
)

var (
    x      int64
    wg     sync.WaitGroup
    lock   sync.Mutex
    rwlock sync.RWMutex
)

const N = 10
const M = 1000

func read() {
    defer wg.Done()
    rwlock.RLock()
    //lock.Lock()
    fmt.Println(x)
    time.Sleep(time.Millisecond)
    //lock.Unlock()
    rwlock.RUnlock()
}

func write() {
    defer wg.Done()
    rwlock.Lock()
    //lock.Lock()
    x = x + 1
    time.Sleep(time.Millisecond * 50)
    //lock.Unlock()
    rwlock.Unlock()
}
func main() {

    start := time.Now()
    for i := 0; i < N; i++ {
        go write()
        wg.Add(1)
    }

    for i := 0; i < M; i++ {
        go read()
        wg.Add(1)
    }

    wg.Wait()
    fmt.Println(time.Now().Sub(start))
}

需要注意的是读写锁非常适合读多写少的场景，如果读和写的操作差别不大，读写锁的优势就发挥不出来。

sync.WaitGroup

在代码中生硬的使用time.Sleep肯定是不合适的，Go语言中可以使用sync.WaitGroup来实现并发任务的同步。 sync.WaitGroup有以下几个方法：

方法名	功能
(wg * WaitGroup) Add(delta int)	计数器+delta
(wg *WaitGroup) Done()	计数器-1
(wg *WaitGroup) Wait()	阻塞直到计数器变为0

sync.WaitGroup内部维护着一个计数器，计数器的值可以增加和减少。例如当我们启动了N 个并发任务时，就将计数器值增加N。每个任务完成时通过调用Done()方法将计数器减1。通过调用Wait()来等待并发任务执行完，当计数器值为0时，表示所有并发任务已经完成。

我们利用sync.WaitGroup将上面的代码优化一下：

var wg sync.WaitGroup

func hello() {
    defer wg.Done()
    fmt.Println("Hello Goroutine!")
}
func main() {
    wg.Add(1)
    go hello() // 启动另外一个goroutine去执行hello函数
    fmt.Println("main goroutine done!")
    wg.Wait()
}

需要注意sync.WaitGroup是一个结构体，传递的时候要传递指针。

【Go】并发问题与锁

sync包

sync.WaitGroup