go - 如何使变量成为线程安全的

Question

我是Go的新手，我需要创建一个线程安全的变量。我知道在Java中您只能使用synchronized关键字，但是go中似乎不存在这样的内容。有什么方法可以同步变量？

Answer 1

Java中的synchronized是仅允许单个线程(在任何给定时间)执行代码块的方法。

在Go中，有许多构造可以实现该目标(例如mutt， channel ，waitgroups， sync/atomic 中的原语)，但是Go的谚语是:“不要通过共享内存进行通信；而是通过通信来共享内存。”

因此，与其锁定和共享变量，不如不要这么做，而要在goroutines之间传递结果，例如使用 channel (因此您不必访问共享内存)。有关详细信息，请参见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进行解锁，因此，如果后续代码中发生不良情况(例如，运行时 panic )，则互斥锁仍将被解锁，避免资源泄漏和死锁。尽管此示例非常简单，但不会发生任何不良情况，并且不能保证无条件使用延迟解锁。

保持互斥锁接近应保护的数据是一种很好的做法。因此，将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()
    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之间存在通信。 Go为这种“内部goroutine”通信提供了出色的支持: channels。语言内置了对 channel 的支持，包括 send statements， receive operators和其他支持(例如，您可以 loop over在 channel 上发送的值)。有关介绍和详细信息，请检查以下答案: What are channels used for?

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

另请参阅相关问题:

Reading values from a different thread