确保变量线程安全的方法

在 Go 语言中，与 Java 中的 `synchronized` 不同，没有直接的同步变量方法。相反，Go 鼓励通过通信共享内存，而不是通过共享内存通信。可以使用互斥体、通道或 `sync/atomic` 包来保护并发访问的变量。对于简单的整数变量，可以使用 `sync/atomic` 包，而对于更复杂的数据结构，则可以使用互斥体。为了避免共享变量，Go 提供了通道，这是一种内置的协程间通信机制，可以安全地发送和接收数据。

我对 Go 比较陌生，我需要使变量成为线程安全的。我知道在java中你可以只使用synchronized关键字，但在go中似乎不存在类似的东西。有没有办法同步变量？

解决方案

java中的synchronized是一种只允许单个线程执行代码块（在任何给定时间）的方法。

在 go 中，有许多构造可以实现这一点（例如互斥体、通道、等待组、sync/atomic 中的原语），但 go 的谚语是：“不要通过共享内存进行通信；相反，通过通信来共享内存。”

因此，与其锁定和共享变量，不如尝试不这样做，而是在 goroutine 之间传递结果，例如使用通道（这样您就不必访问共享内存）。详情请见The Go Blog: Share Memory By Communicating。

当然，在某些情况下，最简单、直接的解决方案可能是使用互斥体来保护多个 goroutine 对变量的并发访问。在这种情况下，您可以这样做：

var (
    mu        sync.mutex
    protectme int
)

func getme() int {
    mu.lock()
    me := protectme
    mu.unlock()
    return me
}

func setme(me int) {
    mu.lock()
    protectme = me
    mu.unlock()
}

上述解决方案可以在几个方面进行改进：

• 使用 sync.RWMutex 而不是 sync.Mutex，这样 getme() 可能会锁定只读，这样多个并发读取器就不会互相阻塞。

• （成功）锁定后，建议使用 defer 解锁，因此如果后续代码中发生问题（例如运行时恐慌），互斥锁仍将被解锁，避免资源泄漏和死锁。虽然这个例子很简单，但不会发生什么不好的事情，并且不能保证无条件使用延迟解锁。

• 最好的做法是让互斥锁靠近它应该保护的数据。因此，将 protectme 及其 mu “包装”在结构中是一个好主意。如果我们这样做，我们还可以使用嵌入，因此锁定/解锁变得更加方便（除非不得公开此功能）。详情见When do you embed mutex in struct in Go?

因此，上述示例的改进版本可能如下所示（在 Go Playground 上尝试一下）：

type me struct {
    sync.rwmutex
    me int
}

func (m *me) get() int {
    m.rlock()
    defer m.runlock()
    return m.me
}

func (m *me) set(me int) {
    m.lock()
    m.me = me
    m.unlock()
}

var me = &me{}

func main() {
    me.set(2)
    fmt.println(me.get())
}

此解决方案还有另一个优点：如果您需要 me 的多个值，它将自动为每个值提供不同的、单独的互斥体（我们最初的解决方案需要为每个新值手动创建单独的互斥体）。

虽然这个例子是正确且有效的，但可能不实用。因为保护单个整数并不真正需要互斥体。我们可以使用 sync/atomic 包实现相同的目的：

var protectMe int32

func getMe() int32 {
    return atomic.LoadInt32(&protectMe)
}

func setMe(me int32) {
    atomic.StoreInt32(&protectMe, me)
}

这个解决方案更短、更干净、更快。如果您的目标只是保护单个值，则首选此解决方案。如果您应该保护的数据结构更复杂，则 atomic 甚至可能不可行，并且使用互斥体可能是合理的。

现在，在展示了共享/保护变量的示例之后，我们还应该举例说明我们应该实现什么目标，以实现“不要通过共享内存进行通信；相反，通过通信来共享内存。”

情况是你有多个并发的 goroutine，并且你使用一个变量来存储一些状态。一个 goroutine 更改（设置）状态，另一个 goroutine 读取（获取）状态。要从多个 goroutine 访问此状态，必须同步访问。

我们的想法是不要有像这样的“共享”变量，而是一个 goroutine 设置的状态，它应该“发送”它，而另一个 goroutine 会读取它应该是状态被“发送到”的那个 goroutine（或者换句话说，另一个 goroutine 应该接收更改后的状态）。因此，两个 goroutine 之间不存在共享状态变量，而是进行通信。 go 为这种“协程间”通信提供了出色的支持：channels。语言内置了对通道的支持，有 send statements、receive operators 和其他支持（例如，您可以 loop over 在通道上发送的值）。有关介绍和详细信息，请查看此答案：What are channels used for?

让我们看一个实际/现实生活中的例子：“经纪人”。代理是“客户端”（goroutine）可以订阅以接收消息/更新的实体，并且代理能够向订阅的客户端广播消息。在一个系统中，有大量客户端可能随时订阅/取消订阅，并且可能需要随时广播消息，以安全的方式同步所有这些将是复杂的。明智地使用通道，这个代理实现相当干净和简单。请允许我不要重复代码，但您可以在这个答案中检查它：How to broadcast message using channel。该实现对于并发使用是完全安全的，支持“无限”客户端，并且不使用单个互斥体或共享变量，仅使用通道。

另请参阅相关问题：

Reading values from a different thread

理论要掌握，实操不能落！以上关于《确保变量线程安全的方法》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！