在 golang 中如何实现并发控制

亲爱的编程学习爱好者，如果你点开了这篇文章，说明你对《在 golang 中如何实现并发控制》很感兴趣。本篇文章就来给大家详细解析一下，主要介绍一下，希望所有认真读完的童鞋们，都有实质性的提高。

问题描述

最近我学会了选项 -race 来检查 go 中是否存在竞争条件。完整的命令是 go run -race xxx.go 它确实对我帮助很大。但与下面的代码一样，我认为检查结果是错误的，并尝试了很多方法（下面的我尝试获得恐慌）来获得real恐慌，但是失败的。所以我想知道代码是否正确以及竞赛检查是否错误，或者您可以修改我的代码以便我可以看到真正的恐慌。非常感谢。

代码

package main
import "fmt"

type mytype struct {
    a int
}

func main(){
    c:=make(chan bool)
    x := new(mytype)
    go func(){
        x = new(mytype) // write to x
        c <- true
    }()
    _ = *x // read from x
    <-c
    fmt.println("end")
}

比赛检查结果

go 运行 -race test.go

==================
warning: data race
write at 0x00c00009c010 by goroutine 6:
  main.main.func1()
      /users/yaodongen/test.go:12 +0x56

previous read at 0x00c00009c010 by main goroutine:
  main.main()
      /users/yaodongen/test.go:15 +0xe2

goroutine 6 (running) created at:
  main.main()
      /users/yaodongen/test.go:11 +0xd4
==================
end
found 1 data race(s)
exit status 66

我的观点

我试图找到竞争条件报告的原因。在一篇文章（中文）中，它提到操作 a = in64(0) 不是原子的。例如，在一台32位机器中，像int64这样的数据可能是64位长度，cpu可以复制一半的数据并被其他数据中断。在下面的代码中（证明golang副本不是原子的），我写了一段代码来证明它的真实性。但就我而言，代码 x = new(mytype) 是复制一个指针值，我认为它可以在一个 cpu 副本中完成。换句话说，该操作是原子的，永远不会达到竞争条件。

证明 golang 副本不是原子的

package main
import "fmt"
import "time"

func main(){
    var x = [...]int{1,1,1,1,1,1}
    c := make(chan int, 100)
    go func(){
        for i:=0;;i++{
            if i&1 == 0 {
                x = [...]int{2,2,2,2,2,2} // write to x
            }else{
                x = [...]int{1,1,1,1,1,1} // write to x
            }
            c<-0 // let other goroutine see the change of x
            <-c
        }
    }()
    go func(){
        for {
            d := x                    // read from x
            if d[0] != d[5] {
                fmt.println(d)
                panic("error")        // proved the copy operation is not atomic
            }
            c<-0
            <-c
        }
    }()
    time.sleep(time.millisecond * 10000)
    fmt.println("end")
}

我试图引起恐慌

但是它失败了，如果存在竞争条件（错误的内存地址），代码将会出现紧急情况。

package main
import "fmt"
import "time"

type myType struct {
    A int
}

func main(){
    x := new(myType)
    c := make(chan int, 100)
    go func(){
        for {
            x = new(myType) // write to x
            c<-0
            <-c
        }
    }()
    for i:=0; i<4; i++{
        go func(){
            for {
                _ = *x // if exists a race condition, `*x` will visit a wrong memory address, and will panic
                c<-0
                <-c
            }
        }()
    }
    time.Sleep(time.Second * 10)
    fmt.Println("end")
}

解决方案

Go 的竞争检测永远不会给出误报。如果它告诉您有一场比赛，那么就有一场比赛。它可能无法识别所有种族（它们必须碰巧是可检测到的），但它发现的总是积极的（种族检测器中的错误不计算在内）。

您的示例中的竞争条件清晰且简单。你有 2 个 goroutine，一个读取变量，另一个在不同步的情况下写入变量。这是竞争条件的秘诀。

竞争条件使您的应用程序变得不可预测。竞争条件的行为是未定义的。任何经历过的行为都属于不确定行为，包括缺乏恐慌。不要诱惑魔鬼，如果存在竞争条件，请使用适当的同步。故事结束。

参见Is it safe to read a function pointer concurrently without a lock?

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《在 golang 中如何实现并发控制》文章吧，也可关注golang学习网公众号了解相关技术文章。