在Go中,使用sync.Mutexchan阻止并发访问共享对象。但是,在某些情况下,我只是对变量或对象字段的最新值感兴趣。
或者我喜欢写一个值,不在乎另一个go例程稍后会覆盖它还是之前已经覆盖它。

更新: TLDR;只是不要这样做。这不安全。阅读答案,评论和链接的文档!

下面是示例程序的goodbad的两种变体,它们似乎都在使用当前Go运行时产生“正确”的输出:

package main

import (
    "flag"
    "fmt"
    "math/rand"
    "time"
)

var bogus = flag.Bool("bogus", false, "use bogus code")

func pause() {
    time.Sleep(time.Duration(rand.Uint32()%100) * time.Millisecond)
}

func bad() {
    stop := time.After(100 * time.Millisecond)
    var name string

    // start some producers doing concurrent writes (DANGER!)
    for i := 0; i < 10; i++ {
        go func(i int) {
            pause()
            name = fmt.Sprintf("name = %d", i)
        }(i)
    }

    // start consumer that shows the current value every 10ms
    go func() {
        tick := time.Tick(10 * time.Millisecond)
        for {
            select {
            case <-stop:
                return
            case <-tick:
                fmt.Println("read:", name)
            }
        }
    }()

    <-stop
}

func good() {
    stop := time.After(100 * time.Millisecond)
    names := make(chan string, 10)

    // start some producers concurrently writing to a channel (GOOD!)
    for i := 0; i < 10; i++ {
        go func(i int) {
            pause()
            names <- fmt.Sprintf("name = %d", i)
        }(i)
    }

    // start consumer that shows the current value every 10ms
    go func() {
        tick := time.Tick(10 * time.Millisecond)
        var name string
        for {
            select {
            case name = <-names:
            case <-stop:
                return
            case <-tick:
                fmt.Println("read:", name)
            }
        }
    }()

    <-stop
}

func main() {
    flag.Parse()
    if *bogus {
        bad()
    } else {
        good()
    }
}


预期的输出如下:
...
read: name = 3
read: name = 3
read: name = 5
read: name = 4
...
read:read: name=[0-9]的任何组合都是此程序的正确输出。接收任何其他字符串作为输出将是一个错误。

当使用go run --race bogus.go运行该程序时,它是安全的。

但是,go run --race bogus.go -bogus警告并发读取和写入。

对于map类型以及附加到 slice 时,我始终需要互斥或类似的保护方法,以避免出现段错误或意外行为。但是,将文字(原子值)读写到变量或字段值似乎是安全的。

问题:我可以安全地读取和安全地写入哪些Go数据类型,而无需使用mutext且不会产生segfaults,也无需从内存中读取垃圾?

解释,以便在您的答案中说明Got 中的某些东西是安全的还是不安全的。

更新:我重写了示例以更好地反映原始代码,其中我遇到了并发写入问题。重要的观点已经在评论中。我将接受一个答案,该答案以足够详细的方式总结了这些学习内容(尤其是在Go运行时中)。

最佳答案

但是,在某些情况下,我只是对变量或对象字段的最新值感兴趣。

这是一个基本问题:“最新”一词是什么意思?

假设从数学上讲,我们有一个序列Xi,其中0 i,则Xj显然比“Xi”大。这是“最新”的一个很好的简单定义,可能就是您想要的。

但是,当一台计算机中的两个单独的CPU(包括Go程序中的两个goroutine)同时工作时,时间本身就失去了的含义。我们不能说i j。因此,“最新”一词没有正确的定义。

为了解决此类问题,现代的CPU硬件以及Go作为一种编程语言为我们提供了某些同步原语。如果CPU A和CPU B执行内存隔离指令或同步指令,或使用任何其他存在的硬件规定,则CPU(和/或某些外部硬件)将插入“时间”概念所需的任何内容,以重新获得其含义。也就是说,如果CPU使用屏障指令,我们可以说在屏障之前执行的内存加载或存储是“之前”,而在屏障之后执行的内存加载或存储是“之后”。

(在某些现代硬件中,实际的实现由加载和存储缓冲区组成,它们可以重新排列加载和存储进入内存的顺序。barrier指令要么同步缓冲区,要么在缓冲区中放置实际的屏障,以便加载和存储缓冲区。这种特殊的具体实现方式为思考问题提供了一种简便的方法,但它并不完整:您应该将时间视为完全不在硬件提供的同步之外,即,来自和除了这些障碍,某些位置同时发生,而不是按顺序出现。)

无论如何,Go的sync包为您提供了一种简单的高级访问方法来访问这些类型的障碍。在互斥量Lock调用之前执行的编译代码确实会在锁定函数返回之前完成,并且在调用之后执行的代码实际上直到锁定函数返回之后才开始。

Go的频道提供了相同的之前/之后时间保证。

Go的sync/atomic包提供了更低级别的保证。通常,应避免这样做,而应使用更高级别的通道或sync.Mutex样式保证。 (编辑以添加注释:您可以在此处使用sync/atomicPointer操作,但不能直接与string类型一起使用,因为Go字符串实际上是作为包含两个单独值的标头实现的:指针和长度。通过更新指向string对象的指针,可以实现另一层间接操作,但是在您考虑这样做之前,您应该对语言的首选方法进行基准测试,并验证这些方法是否存在问题,因为代码可以在sync/atomic级别运行很难编写和调试。)

09-30 15:47
查看更多