当前位置: 首页>>编程语言>>正文


Go语言教程:互斥锁

丹阳 编程语言 , 去评论

返回Go语言教程首页

概念简介

在前面的例子中,我们看到了如何使用原子操作来管理简单的计数器。
对于更加复杂的情况,我们可以使用一个互斥锁
来在 Go 协程间安全的访问数据。

例程代码


package main

import (
    "fmt"
    "math/rand"
    "runtime"
    "sync"
    "sync/atomic"
    "time"
)

func main() {

    // 在我们的例子中,`state` 是一个 map。
    var state = make(map[int]int)

    // 这里的 `mutex` 将同步对 `state` 的访问。
    var mutex = &sync.Mutex{}

    // we'll see later, `ops` will count how many
    // operations we perform against the state.
    // 为了比较基于互斥锁的处理方式和我们后面将要看到的其他
    // 方式,`ops` 将记录我们对 state 的操作次数。
    var ops int64 = 0

    // 这里我们运行 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.AddInt64(&ops, 1)

                // 为了确保这个 Go 协程不会在调度中饿死,我们
                // 在每次操作后明确的使用 `runtime.Gosched()`
                // 进行释放。这个释放一般是自动处理的,像例如
                // 每个通道操作后或者 `time.Sleep` 的阻塞调用后
                // 相似,但是在这个例子中我们需要手动的处理。
                runtime.Gosched()
            }
        }()
    }

    // 同样的,我们运行 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.AddInt64(&ops, 1)
                runtime.Gosched()
            }
        }()
    }

    // 让这 10 个 Go 协程对 `state` 和 `mutex` 的操作
    // 运行 1 s。
    time.Sleep(time.Second)

    // 获取并输出最终的操作计数。
    opsFinal := atomic.LoadInt64(&ops)
    fmt.Println("ops:", opsFinal)

    // 对 `state` 使用一个最终的锁,显示它是如何结束的。
    mutex.Lock()
    fmt.Println("state:", state)
    mutex.Unlock()
}

执行&输出


# 运行这个程序,显示我们对已进行了同步的 `state` 执行了
# 3,500,000 次操作。
$ go run mutexes.go
ops: 3598302
state: map[1:38 4:98 2:23 3:85 0:44]

# 接下来我们将看一下只使用 Go 协程和通道是如何实现
# 相同的状态控制任务的。

课程导航

学习上一篇:Go语言教程:原子计数器    学习下一篇:Go语言教程:状态协程

相关资料

本例程github源代码:https://github.com/xg-wang/gobyexample/tree/master/examples/mutexes

Go语言互斥锁

本文由《纯净的天空》出品。文章地址: https://vimsky.com/article/4072.html,未经允许,请勿转载。

相关文章



猜你喜欢