同时进行读取或写入操作会导致什么问题发生？

怎么入门Golang编程？需要学习哪些知识点？这是新手们刚接触编程时常见的问题；下面golang学习网就来给大家整理分享一些知识点，希望能够给初学者一些帮助。本篇文章就来介绍《同时进行读取或写入操作会导致什么问题发生？》，涉及到，有需要的可以收藏一下

在 go 中，使用 sync.mutex 或 chan 来防止共享对象的并发访问。但是，在某些情况下，我只对对象的变量或字段的“最新”值感兴趣。 或者我喜欢写一个值，并不关心另一个 go 例程稍后会覆盖它还是之前刚刚覆盖它。

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

2021 年更新： go 内存模型将被更彻底地指定，russ cox 撰写的三篇精彩文章将教您更多关于不同步内存访问的令人惊讶的影响。这些文章总结了以下大量讨论和学习内容。

以下是示例程序的两个变体 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 数据类型，而无需互斥，不会产生段错误，也不会从内存中读取垃圾？

请在您的答案中解释为什么某些内容在 go 中是安全或不安全的。

更新：我重写了示例以更好地反映原始代码，其中我遇到了并发写入问题。重要的倾向已经在评论中了。我会接受一个答案，该答案足够详细地总结了这些知识（尤其是在 go 运行时）。

解决方案

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

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

假设，从数学上来说，我们有一个值序列 X_i，其中 0 <= i < N。那么显然 X_j 是“晚于”X_i 如果 j > i 。这是“最新”的一个很好的简单定义，并且可能就是您想要的。

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

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

（在某些现代硬件中，实际的实现由加载和存储缓冲区组成，它们可以重新排列加载和存储进入内存的顺序。屏障指令要么同步缓冲区，要么在其中放置一个实际的屏障，因此加载和存储不能越过障碍。这个特定的具体实现提供了一种简单的方法来思考这个问题，但并不完整：您应该将时间视为硬件之外不存在 -提供同步，即所有从某个位置的加载和存储到某个位置都是同时发生的，而不是按某种顺序发生，除了这些障碍之外。）

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

Go 的通道提供相同类型的之前/之后时间保证。

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

没有。

事情就是这么简单：在任何情况下，你都不能同时读取和写入 Go 中的任何内容。

（顺便说一句：你的“正确”程序并不正确，它是活泼的，即使你摆脱了竞争条件，它也不会确定地产生输出。）

到这里，我们也就讲完了《同时进行读取或写入操作会导致什么问题发生？》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！