Goroutine与锁
在进行并发编程时，很多时候都需要涉及到变量的共享，下面这段代码创建了2个Goroutine来访问变量a并对a进行自加操作，a预期结果应为200000
goroutine-without-lock.go
package main
import (
"fmt"
"sync"
)
func main() {
a := 0
var n sync.WaitGroup
for i := 0; i < 2; i++ {
n.Add(1)
go func() {
defer n.Done()
for j := 0; j < 100000; j++ {
a++
}
}()
} //创建2个Goroutine
n.Wait()
fmt.Printf("a = %d\n", a)
}
大多数情况下并不能得到正确的结果
假设此时a的值为10000，那么在Goroutine [1]读取a的值后，并且未在内存中写入a加1之后的值的这段时间，如果Goroutine [2]此时访问a的值，它得到的值为10000，而不是10001，这样就造成了Goroutine [2]并没有读取到Goroutine [1]更新后的数值，因此会出现少加的情况
解决该问题的办法就是当Goroutine涉及到有关变量a的执行语句时，要确保读取和写入操作完成后其它Goroutine才能访问变量a
goroutine-with-lock.go
package main
import (
"fmt"
"sync"
)
func main() {
a := 0
var mu sync.Mutex
var n sync.WaitGroup
for i := 0; i < 2; i++ {
n.Add(1)
go func() {
defer n.Done()
for j := 0; j < 100000; j++ {
mu.Lock()
a++
mu.Unlock()
}
}()
}
n.Wait()
fmt.Printf("a = %d\n", a)
}
每当Goroutine执行到涉及变量a的语句时，先申请锁，更新完a的值后在释放锁，当一个Goroutine持有锁时，其它的Goroutine都会等待锁释放后再执行申请锁的操作，这样就保证了每次只有一个Goroutine执行变量a的读取和写入操作
加锁的技巧
为了避免程序运行时不必要的等待，在加锁时需要注意仅当Goroutine需要更改共享变量的值时再获取锁，更改完共享变量的值立刻释放锁
一个不恰当的例子
lock-whole-goroutine-execution_time.go
package main
import (
"fmt"
"sync"
"time"
)
const (
UNASSIGN = 0 //未分配
COMPLETED = 1 //执行完毕
)
func main() {
task := make([]int, 10)
var mu sync.Mutex
var n sync.WaitGroup
for index := range task {
task[index] = UNASSIGN
}
for index := range task {
n.Add(1)
go func(index int) {
defer n.Done()
mu.Lock()
time.Sleep(1 * time.Second)
task[index] = COMPLETED
mu.Unlock() //在整个Goroutine加锁
}(index)
}
n.Wait()
fmt.Printf("All task done!\n")
}
在这个例子中，由于在整个Goroutine执行语句进行加锁，导致整个程序执行了10s，结果和串行执行所需时间一样
如果在Goroutine中等待任务完成后(time.Sleep(1 * time.Second)在此处相当于执行任务，通常情况下任务可以为I/O读写，爬虫请求等等)，再申请锁会极大的加快程序执行效率，将上面的代码time.Sleep(1 * time.Second)与mu.Lock()互换位置再执行，整个程序仅需1s就可以执行完毕
上述代码其实不适用sync.WaitGroup也可以实现等待操作，主要思想就是通过循环遍历检查所有的任务是否执行完毕，如果所有任务执行完毕退出循环
lock-without-waitgroup.go
package main
import (
"fmt"
"sync"
"time"
)
const (
UNASSIGN = 0 //未分配
COMPLETED = 1 //执行完毕
)
func main() {
task := make([]int, 10)
var mu sync.Mutex
for index := range task {
task[index] = UNASSIGN
}
for index := range task {
go func(index int) {
time.Sleep(1 * time.Second)
mu.Lock()
task[index] = COMPLETED
mu.Unlock()
}(index)
}
for {
taskDone := true
for index := range task {
taskDone = taskDone && (task[index] == COMPLETED)
} //当所有任务执行完毕时，taskDone为true
if taskDone {
break
} //当所有任务执行完毕时，退出循环
}
fmt.Printf("All task done!\n")
}
上面的代码还可以优化一下，由于使用的是for {}语句，会一直占用CPU，为了避免其一直占用CPU，在for循环内部可以添加time.Sleep(100 * time.Millisecond)
