Go并发编程：保障安全与解锁奥秘

一、并发安全与锁

1、并发安全

有时候在 Go 代码中可能会存在多个 goroutine 同时操作一个资源（临界区），这种情况会发生竞态问题（数据竞态）
类比现实生活中的例子有十字路口被各个方向的汽车竞争；还有火车上的卫生间被车厢里的人竞争
下面开启两个携程，对变量 x 加一操作，分别加 5000 次，理想结果是 10000，实际三次结果都不相同

Go 复制代码

package main

import (
    "fmt"
    "sync"
)

var x int64
var wg sync.WaitGroup

func 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)
}

/*
第一次结果：6125
第二次结果：6217
第三次结果：10000

*/

2、互斥锁

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

Go 复制代码

package main

import (
	"fmt"
	"sync"
)

var x int64
var wg sync.WaitGroup
var lock sync.Mutex

func 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)   // 10000
}

3、读写互斥锁

互斥锁是完全互斥的，但是有很多实际的场景下是读多写少的
当我们并发的去读取一个资源不涉及资源修改的时候是没有必要加锁的，这种场景下施用读写锁是更好的一种选择
读写锁在 Go 语言中施用 sync 包中的 RWMutex 类型
读写锁分为两种：读锁和写锁
- 当一个 goroutine获取读锁之后，其他的 goroutine 如果是获取读锁会继续获得锁，如果是获取写锁就会等待
- 当一个 goroutine 获取写锁之后，其他的 goroutine 无论是获取读锁还是写锁都会等待
注意：是读写锁非常适合读多写少的场景，如果读和写的操作差别不大，读写锁的优势就发挥不出来

Go 复制代码

package main

import (
	"fmt"
	"strconv"
	"sync"
)

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()
}

二、sync 其他方法

1、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 将上面的代码优化一下：

Go 复制代码

package main

import (
	"fmt"
	"sync"
)

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()
}

2、sync.Once

在编程的很多场景下我们需要确保某些操作在高并发的场景下只执行一次，例如只加载一次配置文件，只关闭一次通道等
Go 语言中的 sync 包中提供了一个针对值执行一次场景的解决方案-sync.Once
sync.Once只有一个 Do 方法，其签名如下：

Go 复制代码

var icons map[string]image.Image

var loadIconsOnce sync.Once

func loadIcons() {
	icons = map[string]image.Image{
		"left":  loadIcon("left.png"),
		"up":    loadIcon("up.png"),
		"right": loadIcon("right.png"),
		"down":  loadIcon("down.png"),
	}
}

// Icon 是并发安全的
func Icon(name string) image.Image {
	loadIconsOnce.Do(loadIcons)
	return icons[name]
}

3、Sync.Map

Go语言中内置的map不是并发安全的。请看下面的示例
下面的代码开启少量几个goroutine的时候可能没什么问题
当并发多了之后执行上面的代码就会报fatal error: concurrent map writes错误
原因:
- 因为 map 变量为指针类型变量，并发写时，多个协程同时操作一个内存
- 类似于多线程操作同一个资源会发生竞争关系，共享资源会遭到破坏
- 因此golang 出于安全的考虑，抛出致命错误：fatal error: concurrent map writes

Go 复制代码

package main

import (
	"fmt"
	"strconv"
	"sync"
)

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()
}

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

Go 复制代码

package main

import (
	"fmt"
	"strconv"
	"sync"
)

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()
}