如何使变量线程安全

今日不肯埋头，明日何以抬头！每日一句努力自己的话哈哈~哈喽，今天我将给大家带来一篇《如何使变量线程安全》，主要内容是讲解golang等等，感兴趣的朋友可以收藏或者有更好的建议在评论提出，我都会认真看的！大家一起进步，一起学习！

问题内容

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

正确答案

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

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

因此，与其锁定和共享变量，不如尝试不这样做，而是在 goroutine 之间传递结果，例如使用通道（这样您就不必访问共享内存）。有关详细信息，请参阅Go 博客：通过通信共享内存。

当然，在某些情况下，最简单、直接的解决方案是使用互斥锁来保护多个 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在一个结构中是一个好主意。而且如果我们这样做，我们还可以使用嵌入，因此锁定/解锁变得更加方便（除非这个功能不能暴露）。有关详细信息，请参阅Go 中何时在 struct 中嵌入互斥锁？

因此，上述示例的改进版本可能如下所示（在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 应该 接收 更改的状态）。所以没有共享状态变量，而是在 2 个 goroutine 之间进行 通信。 Go 为这种“goroutine 间”通信提供了极好的支持：通道。语言中内置了对通道的支持，有发送语句、接收运算符和其他支持（例如，您可以循环在通道上发送的值）。有关介绍和详细信息，请查看此答案：[频道用于什么？](https://stackoverflow.com/questions/39826692/what- are-golang-channels-used-for/39826883#39826883)

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

另请参阅相关问题：

[从不同线程读取值](https://stackoverflow.com/questions/49444734/reading-values-from-a- different-thread/49445102#49445102)

本篇关于《如何使变量线程安全》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！