Go 如何检测并发竞争条件的原因

学习Golang要努力，但是不要急！今天的这篇文章《Go 如何检测并发竞争条件的原因》将会介绍到等等知识点，如果你想深入学习Golang，可以关注我！我会持续更新相关文章的，希望对大家都能有所帮助！

我编写了一些简单的 go 代码来理解竞争条件，如下所示：

package main

import (
    "fmt"
    "sync"
)

type outer struct {
    sync.mutex
    num int
    foo string
}

func (outer *outer) modify(wg *sync.waitgroup) {
    outer.lock()
    defer outer.unlock()
    outer.num = outer.num + 1
    wg.done()
}

func main() {
    outer := outer{
        num: 2,
        foo: "hi",
    }
    var w sync.waitgroup
    for j := 0; j < 5000; j++ {
        w.add(1)
        go outer.modify(&w)
    }
    w.wait()
    fmt.printf("final is %+v", outer)

}

当我在上面运行时，打印的答案始终是正确的，即 num 始终是 5002。 如果没有锁，由于 forloop 中创建的 goroutine 之间存在竞争，结果将无法预测。

但是，当我使用 -race 运行此命令时，会检测到以下竞争条件：

go run -race random.go
==================
WARNING: DATA RACE
Read at 0x00c00000c060 by main goroutine:
  main.main()
      random.go:32 +0x15d

Previous write at 0x00c00000c060 by goroutine 22:
  sync/atomic.AddInt32()
      /usr/local/go/src/runtime/race_amd64.s:269 +0xb
  sync.(*Mutex).Unlock()
      /usr/local/go/src/sync/mutex.go:182 +0x54
  main.(*outer).modify()
      random.go:19 +0xb7

Goroutine 22 (finished) created at:
  main.main()
      random.go:29 +0x126
==================
Final is {Mutex:{state:0 sema:0} num:5002 foo:hi}Found 1 data race(s)
exit status 66

即。它正在检测最终的 printf 和在其之前创建的一个随机 go 例程之间的竞争。 由于我使用等待来同步，所以当我们到达 printf 时，所有 go 例程都已完成。

比赛被报道的原因是什么？

打印结构时我也需要锁定吗？

解决方案

sync.waitgroup 使用不当是导致竞争状况的原因。其中任何一个都应该正常工作：

func (outer *outer) modify(wg *sync.waitgroup) {
    outer.lock()
    outer.num = outer.num + 1
    outer.unlock()
    wg.done()
}

func (outer *outer) modify(wg *sync.waitgroup) {
    outer.lock()
    defer wg.done()
    defer outer.unlock()
    outer.num = outer.num + 1
}

wg.done() 应该在解锁互斥锁之后调用（延迟调用以 lifo 方式进行），因为之前调用它会导致 printf() 调用与最后一个 outer.unlock() 调用竞争访问 outer。

package main

import (
    "fmt"
    "sync"
)

type outer struct {
    *sync.Mutex
    num int
    foo string
}

func (outer *outer) modify(wg *sync.WaitGroup) {
    outer.Lock()
    defer outer.Unlock()
    outer.num++
    wg.Done()
}

func main() {
    outer := outer{
        Mutex: &sync.Mutex{},
        num:   2,
        foo:   "hi",
    }
    w := &sync.WaitGroup{}
    for j := 0; j < 5000; j++ {
        w.Add(1)
        go outer.modify(w)
    }
    w.Wait()
    fmt.Printf("Final is %+v", outer)
}

将sync.mutex更改为指针。

我认为这是由于sync.mutex在您的版本中很有价值

本篇关于《Go 如何检测并发竞争条件的原因》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！