在前面的例子中,我们看到了如何使用原子操作来管理简单的计数器。 对于更加复杂的情况,我们可以使用一个互斥锁 来在 Go 协程间安全的访问数据。 示例代码如下:
// Go by Example 中文:互斥锁
// https://books.studygolang.com/gobyexample/mutexes/
// 在前面的例子中,我们看到了如何使用原子操作来管理简单的计数器。
// 对于更加复杂的情况,我们可以使用一个互斥锁来在 Go 协程间安全的访问数据。
package main
import (
"fmt"
"math/rand"
"sync"
"sync/atomic"
"time"
)
func main() {
// state 是一个map
var state = make(map[int]int)
// 这里的 mutex 将同步对 state 的访问。
var mutex = &sync.Mutex{}
// 我们会持续追踪读写操作的数量。
// readOps 将记录我们对 state 的读操作次数
var readOps uint64
// writeOps 将记录我们对 state 的写操作次数
var writeOps uint64
// 这里我们运行100个Go协程来重复读取state
for r := 0; r < 100; r++ {
go func() {
total := 0
for {
/*
每次循环读取,我们使用一个键来进行访问,Lock() 这个 mutex 来确保对 state 的独占访问,
读取选定的键的值,Unlock() 这个mutex,并且 ops 值加 1。
*/
key := rand.Intn(5)
mutex.Lock()
total += state[key]
mutex.Unlock()
atomic.AddUint64(&readOps, 1)
/*
在下次读取前等到片刻。
*/
time.Sleep(time.Millisecond)
}
}()
}
// 同样的,我们运行10个Go协程来模拟写入操作,使用和读取相同的模式
for w := 0; w < 10; w++ {
go func() {
for {
key := rand.Intn(5)
val := rand.Intn(100)
mutex.Lock()
state[key] = val
mutex.Unlock()
atomic.AddUint64(&writeOps, 1)
time.Sleep(time.Millisecond)
}
}()
}
// 让这 10 个 Go 协程对 state 和 mutex 的操作运行 1 s。
time.Sleep(time.Second)
// 获取并输出最终的操作计数。
readOpsFinal := atomic.LoadUint64(&readOps)
fmt.Println("readOps:", readOpsFinal)
wrtieOpsFinal := atomic.LoadUint64(&writeOps)
fmt.Println("writeOps:", wrtieOpsFinal)
// 对 state 使用一个最终的锁,显示它是如何结束的。
mutex.Lock()
fmt.Println("state:", state)
mutex.Unlock()
}
运行这个程序,显示我们进行了大约 90,000 次 mutex 同步的 state 操作。
$ go run mutexes.go
readOps: 83285
writeOps: 8320
state: map[1:97 4:53 0:33 2:15 3:2]
我在自己的Windows10下的GoLand下运行的结果截图如下图所示:
接下来我们将看一下,只使用协程和通道, 如何实现相同的任务状态管理。
下一个例子: [状态协程](https://gobyexample-cn.github.io/stateful-goroutines)