没有互斥量的情况下同时进行读写时会发生什么

Question

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

更新： TLDR；只是不要这样做。这不安全。阅读答案，评论和链接的文档！

这里有两个变量good和bad一个示例程序，其中似乎都使用当前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类型和附加到切片时，我始终需要互斥或类似的保护方法，以避免出现段错误或意外行为。但是，将文字（原子值）读写到变量或字段值 似乎 是安全的。

问题： 我可以安全地读取和安全地并发写入哪些Go数据类型，而无需使用mutext，不产生段错误以及不从内存中读取垃圾？

请 解释 为什么有些东西是 安全的或不安全的围棋 在你的答案。

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

Answer 1

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

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

从数学上讲，假设我们有一个值 X i_的序列，其中 _0 <= i <N。那么很明显， X Ĵ_是“晚于” _X 我，如果 _J

时我_。这是“最新”的一个很好的简单定义，可能就是您想要的。

但是，当一台机器上的两个单独的CPU（包括Go程序中的两个goroutine）同时工作 时 ， 时间本身就失去了意义 。我们不能说i j。因此，没有对“ 最新 ”一词的正确定义。

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

（在某些现代硬件中，实际实现由加载和存储缓冲区组成，这些缓冲区可以重新排列加载和存储进入内存的顺序。barrier指令要么同步缓冲区，要么在缓冲区中放置实际的屏障，以便加载和存储缓冲区。商店无法跨越屏障移动这种特殊的具体实施给出了一个简单的方法来思考这个问题，但不完整：你应该考虑的时间，根本
不存在 硬件提供的同步之外，即 所有 的负荷，除了这些障碍，某些位置同时发生，而不是按顺序出现。）

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

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

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