学习 Go 同步存储，让你的程序更高效

Go 语言（Golang）作为一门高效、并发、并行的编程语言，一直受到广大开发者的青睐。在 Go 语言中，同步存储是一个非常重要的概念。本文将向您介绍 Go 语言中的同步存储，并通过演示代码，让您更好地理解和应用它。

同步存储是什么？

在计算机科学中，同步存储是指多个线程或进程在对共享变量进行访问时，保证它们的访问顺序是一致的。在 Go 语言中，同步存储是通过 sync 包中的 Mutex、RWMutex 和 WaitGroup 等类型实现的。

Mutex

Mutex 全称为 Mutual Exclusion，是互斥锁的意思。在 Go 语言中，Mutex 可以保证同一时刻只有一个 goroutine（go 协程）可以访问共享资源。当一个 goroutine 请求 Mutex 时，如果 Mutex 已经被锁定，那么它就会阻塞等待，直到 Mutex 被解锁。

下面是一个使用 Mutex 的简单例子：

package main

import (
    "fmt"
    "sync"
)

var (
    count int
    mutex sync.Mutex
)

func main() {
    for i := 0; i < 10; i++ {
        go increment()
    }

    for i := 0; i < 10; i++ {
        go decrement()
    }

    fmt.Scanln()
    fmt.Println("Count:", count)
}

func increment() {
    mutex.Lock()
    count++
    fmt.Println("Increment:", count)
    mutex.Unlock()
}

func decrement() {
    mutex.Lock()
    count--
    fmt.Println("Decrement:", count)
    mutex.Unlock()
}

在上面的代码中，我们创建了一个计数器 count，然后使用 Mutex 来保证在对 count 进行增量和减量操作时，同一时刻只有一个 goroutine 可以访问。可以看到，当多个 goroutine 同时对 count 进行增量或减量操作时，输出的结果是交替出现的，而不是混乱的。

RWMutex

RWMutex 全称为 Reader-Writer Mutex，是读写锁的意思。在 Go 语言中，RWMutex 可以保证多个 goroutine 可以同时读取共享资源，但只有一个 goroutine 可以对共享资源进行写操作。当一个 goroutine 请求 RWMutex 进行写操作时，如果 RWMutex 已经被锁定，则它会阻塞等待，直到 RWMutex 被解锁。当多个 goroutine 请求 RWMutex 进行读操作时，如果 RWMutex 没有被锁定，则它们可以同时访问共享资源。

下面是一个使用 RWMutex 的简单例子：

package main

import (
    "fmt"
    "sync"
)

var (
    count int
    rwMutex sync.RWMutex
)

func main() {
    for i := 0; i < 10; i++ {
        go read()
    }

    for i := 0; i < 10; i++ {
        go write()
    }

    fmt.Scanln()
    fmt.Println("Count:", count)
}

func read() {
    rwMutex.RLock()
    fmt.Println("Read:", count)
    rwMutex.RUnlock()
}

func write() {
    rwMutex.Lock()
    count++
    fmt.Println("Write:", count)
    rwMutex.Unlock()
}

在上面的代码中，我们创建了一个计数器 count，然后使用 RWMutex 来保证多个 goroutine 可以同时读取 count，但只有一个 goroutine 可以对 count 进行写操作。可以看到，当多个 goroutine 同时读取 count 时，输出的结果是同时出现的，而当一个 goroutine 进行写操作时，其他 goroutine 都会阻塞等待。

WaitGroup

WaitGroup 是一个计数器，用于等待一组 goroutine 执行完成。在 WaitGroup 中，Add 方法用于增加计数器的值，Done 方法用于减少计数器的值，Wait 方法用于等待计数器的值减为 0。

下面是一个使用 WaitGroup 的简单例子：

package main

import (
    "fmt"
    "sync"
)

var (
    count int
    waitGroup sync.WaitGroup
)

func main() {
    for i := 0; i < 10; i++ {
        waitGroup.Add(1)
        go increment()
    }

    waitGroup.Wait()
    fmt.Println("Count:", count)
}

func increment() {
    defer waitGroup.Done()
    count++
    fmt.Println("Increment:", count)
}

在上面的代码中，我们创建了一个计数器 count，然后使用 WaitGroup 来保证在多个 goroutine 对 count 进行增量操作时，只有当所有 goroutine 执行完成后，才输出最终的 count 值。可以看到，当所有 goroutine 执行完成后，输出的 count 值是正确的。

总结

通过上述介绍和演示代码，我们了解了 Go 语言中的同步存储，包括 Mutex、RWMutex 和 WaitGroup 等类型。在实际开发中，我们可以根据不同的情况选择合适的类型来实现同步存储，从而提高程序的效率和可靠性。