并发和竞态

程序并发运行时，如果多个线程同时对内存变量，进行读取和修改，可能导致错误的处理结果。
例: 一个收款账号，同时收到多笔打款. 这时，我们说这个程序存在 数据竞态。

Go语言中，如果无法确定两个 goroutine 中代码的执行顺序。就可以说这两个 goroutine 是并发执行的。

如果一段代码无论是顺序执行还是并发执行，结果都是正确的，那就可以说这个代码是 并发安全的。

消除竞态

不修改变量

变量常驻内存，不再修改。常用于启动时初始化配置项。运行时不再改变。

不要多个 goroutine 中去访问同一个变量。

goroutine + channel: 通过 channel 阻塞来更新变量.

这也符合 Go 的设计理念：不要通过共享内存来通信，而应该通过通信来共享内存。

同一时间只允许一个 goroutine 访问变量

同一时间只允许一个 goroutine 访问变量，其他 goruotine 需要等到当前的访问结束后，才能访问，这样也可以消除竞态。
本文重点介绍此方案

Go 提供的并发工具

互斥锁 sync.Mutex

互斥锁 是解决竞态最经典的工具，Go语言使用 sync.Mutex.

原理: 如果要访问一个资源，必须拿到这个资源的锁，才有资格访问. 其他 goroutine 想访问，必须等当前 goroutine 释放了锁，抢到锁之后再访问.

每个拿到锁的 goroutine 都需要保证在对变量的访问结束之后，把锁释放掉. 即使发生在异常情况，也需要释放.

这里可以使用 defer 来保证最终会释放锁：

var mu sync.Mutex
var balance int
func Deposit(amount int) {
    mu.Lock()
    defer mu.Unlock()
    balance = balance + amount
}

func Balance() int {
    mu.Lock()
    defer mu.Unlock()
    return balance
}

读写互斥锁 sync.RWMutex

上面的互斥锁解决了访问数据的竞态问题，但是读余额的操作有点低效。每次来读余额的时候，都还需要去抢锁，实际上，这个变量如果没有改变，即使同时被多个 goroutine 读，也不会产生并发安全的问题。

我们想要的一个理想的场景就是，如果这个变量没有在写入，就可以运行多个 goroutine 同时读，这样可以大大提高效率。
Go语言提供 sync.RWMutex(读写互斥锁)，解决此问题。

var mu sync.RWMutex // 替换 sync.Mutex
var balance int

Go 也提供了这个工具，那就是读写锁。这个锁读与读是不互斥的，简单来说就是这个锁可以保证同时只能有一个 goroutine 在写入，如果有 goroutine 在写入，其他的 goroutine 既不能读，也不能写，但允许多个 goroutine 同时来读。

sync.Once

sync.Once 可以保证代码只会执行一遍，多用于资源初始化等场景。

o := &sync.Once{}
for i := 0; i < 100; i++ {
    o.Do(func(){
        go func() {
            Deposit(100)
        }()

        go func() {
            Deposit(100)
        }()
    })
}
// 休眠一秒，让上面的 goroutine 执行完成
time.Sleep(1 * time.Second)
fmt.Println(Balance())

竞态检测器

很多处在竞态的错误很难发现，Go 语言中提供了一个工具，可以帮忙检查代码中是否存在竞态。使用起来很简单，只需要在以下命令之后加上 -race 参数就可以：

go run -race
go build -race
go test -race

编译器会对代码在执行时对所有共享变量的访问，如果发现一个 goroutine 写入一个变量之后，没有任何同步的操作，就有另外一个 goroutine 读写了这个变量，那就说明这里存在竞态，就会报错.

Golang开发中如何解决共享变量问题 https://www.jb51.net/article/223657.htm