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

在Go中，有很多构造可以实现该目标（例如互斥体，通道，等待组，中的原语sync/atomic），但是Go的谚语是：
“不要通过共享内存进行通信；而是通过通信来共享内存。”

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

当然，在某些情况下，最简单，直接的解决方案是使用互斥锁来保护从多个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结构体是一个好主意。而且，如果需要的话，我们也可以使用嵌入，因此锁定/解锁变得更加方便（除非不得公开此功能）

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

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为这种“内部沟通”通信：渠道提供了出色的支持。语言内置了对通道的支持，其中包括send语句，receive运算符和其他支持（例如，您可以循环在通道上发送的值）。

让我们看一个实际的现实例子：“经纪人”。代理是“客户端”（goroutine）可以订阅以接收消息/更新的实体，并且代理能够将消息广播到订阅的客户端。在一个系统中，有许多客户端随时可能订阅/取消订阅，并且可能需要随时广播消息，因此以安全的方式同步所有这些操作将很复杂。明智地使用渠道，此代理实现非常干净和简单。该实现对于并发使用是完全安全的，支持“无限”客户端，并且不使用单个互斥或共享变量，仅使用通道。

另请参阅相关问题：

从其他线程读取值