互斥是并发编程中最关键的概念之一。当我们使用 goruntine 和channels 进行并发编程时，如果两个 goruntine 尝试同时访问同一个内存位置的同一数据会发生竞争，有时候会产生意想不到的结果，通常很难调试，不符合日常要求，出现错误甚至很难修复。
生活场景
假设在生活中可能会发生的例子：有一个银行系统，我们可以从银行余额中存款和取款。在一个单线程的同步程序中，这个操作很简单。我们可以通过少量的单元测试有效地保证它每次都能按计划工作。
然而，如果我们开始引入多个线程，在 Go 语言中使用多个 goroutine，我们可能会开始在我们的代码中看到问题。
- 假如有一个余额为 1000 元的客户。
- 客户将 500 元存入他的账户。
- 一个 goroutine 会看到这个交易，读取价值为 1000 ，并继续将 500 添加到现有的余额中。(此时应该是 1500 的余额)
- 然而，在同一时刻，他拿 800 元来还分期付款的 iphone 13.
- 第二个程序在第一个程序能够增加 500 元的额外存款之前，读取了 1000 元的账户余额，并继续从他的账户中扣除 800 元。(1000 - 800 = 200)
- 第二天，客户检查了他的银行余额，发现他的账户余额减少到了 200 元，因为第二个程序没有意识到第一笔存款，并在存款完成前做了扣除操作。
这就是一个线程竞赛的例子，如果我们不小心落入这样的代码，我们的并发程序就会出现问题。
互斥锁和读写锁
互斥锁，英文名 Mutex，顾名思义，就是相互排斥，是保护程序中临界区的一种方式。
而临界区是程序中需要独占访问共享资源的区域。互斥锁提供了一种安全的方式来表示对这些共享资源的独占访问。
为了使用资源，channel 通过通信共享内存，而 Mutex 通过开发人员的约定同步访问共享内存。
让我们看一个没有 Mutex 的并发编程示例
package main
import (
"fmt"
"sync"
)
type calculation struct {
sum int
}
func main() {
test := calculation{}
test.sum = 0
wg := sync.WaitGroup{}
for i := 0; i < 500; i++ {
wg.Add(1)
go dosomething(&test, &wg)
}
wg.Wait()
fmt.Println(test.sum)
}
func dosomething(test *calculation, wg *sync.WaitGroup) {
test.sum++
wg.Done()
}
第一次结果为：491
第二次结果：493
[Running] go run "e:\Coding Workspaces\LearningGoTheEasiestWay\concurrency\mutex\v0\main.go"
493
在上面的例子中，我们声明了一个名为 test 的计算结构体，并通过 for 循环产生了多个 GoRoutines，将 sum 的值加 1。(如果你对 GoRoutines 和 WaitGroup 不熟悉，请参考之前的教程)。 我们可能期望 for 循环后 sum 的值应该是 500。然而，这可能不是真的。 有时，您可能会得到小于 500(当然永远不会超过 500)的结果。 这背后的原因是两个 GoRoutine 有一定的概率在相同的内存位置操作相同的变量，从而导致这种意外结果。 这个问题的解决方案是使用互斥锁。
使用 Mutex
package main
import (
"fmt"
"sync"
)
type calculation struct {
sum int
mutex sync.Mutex
}
func main() {
test := calculation{}
test.sum = 0
wg := sync.WaitGroup{}
for i := 0; i < 500; i++ {
wg.Add(1)
go dosomething(&test, &wg)
}
wg.Wait()
fmt.Println(test.sum)
}
func dosomething(test *calculation, wg *sync.WaitGroup) {
test.mutex.Lock()
test.sum++
test.mutex.Unlock()
wg.Done()
}
结果为：
[Running] go run "e:\Coding Workspaces\LearningGoTheEasiestWay\concurrency\mutex\v0.1\main.go"
500
在第二个示例中，我们在结构中添加了一个互斥锁属性，它是一种类型的 sync.Mutex。然后我们使用互斥锁的 Lock() 和 Unlock() 来保护 test.sum 当它被并发修改时，即 test.sum++。
请记住，使用互斥锁并非没有后果，因为它会影响应用程序的性能，因此我们需要适当有效地使用它。 如果你的 GoRoutines 只读取共享数据而不写入相同的数据，那么竞争条件就不会成为问题。 在这种情况下，您可以使用 RWMutex 代替 Mutex 来提高性能时间。
Defer 关键字
对 Unlock() 使用 defer 关键字通常是一个好习惯。
func dosomething(test *calculation) error{
test.mutex.Lock()
defer test.mutex.Unlock()
err1 :=...
if err1 != nil {
return err1
}
err2 :=...
if err2 != nil {
return err2
}
// ... do more stuff ...
return nil
}
在这种情况下，我们有多个 if err!=nil 这可能会导致函数提前退出。 通过使用 defer，无论函数如何返回，我们都可以保证释放锁。 否则，我们需要将 Unlock() 放在函数可能返回的每个地方。 然而，这并不意味着我们应该一直使用 defer。 让我们再看一个例子。
func dosomething(test *calculation){
test.mutex.Lock()
defer test.mutex.Unlock()
// modify the variable which requires mutex protect
test.sum =...
// perform a time consuming IO operation
http.Get()
}
在这个例子中，mutex 不会释放锁，直到耗时的函数(这里是 http.Get())完成。 在这种情况下，我们可以在 test.sum=... 行之后解锁互斥锁，因为这是我们操作变量的唯一地方。
总结
很多时候 Mutex 并不是单独使用的，而是嵌套在 Struct 中使用，作为结构体的一部分，如果嵌入的 struct 有多个字段，我们一般会把 Mutex 放在要控制的字段上面，然后使用空格把字段分隔开来。
甚至可以把获取锁、释放锁、计数加一的逻辑封装成一个方法。
