GO语言Mutex的最全解析，一文帮你玩转共享资源管理！

2022-12-06 17:30:22

互斥锁：同步共享资源的看门人

在并发编程中，协调多个线程同时访问共享资源至关重要。想象一下在一个餐馆里，多个服务员同时接单。如果没有适当的机制来协调他们的工作，将会发生混乱，订单将被搞得一团糟。这就是互斥锁发挥作用的地方，它就像餐馆里的领位员，确保服务员一次只为一张桌子服务。

什么是互斥锁？

互斥锁是一种同步机制，用于保护共享资源不被并发访问。在 Go 语言中，它通过 sync.Mutex 类型实现。互斥锁以一种 "要么全部，要么没有" 的方式工作。换句话说，一次只能有一个线程持有互斥锁。

互斥锁的工作原理

获取锁： 当一个线程需要访问共享资源时，它必须首先获取互斥锁。如果互斥锁已经被其他线程持有，该线程将被阻塞，直到互斥锁被释放。
释放锁： 当一个线程不再需要访问共享资源时，它必须释放互斥锁。这使得其他线程可以获取互斥锁并访问共享资源。

互斥锁的应用场景

互斥锁在并发编程中非常有用，包括：

保护共享数据： 确保多个线程不会同时修改共享数据，防止数据不一致。
同步线程： 协调线程按特定顺序执行。
资源管理： 限制对有限资源的并发访问，防止资源过度使用。

互斥锁的代码示例

package main

import (
    "fmt"
    "sync"
)

var mutex sync.Mutex
var sharedCount int

func main() {
    const numThreads = 5

    var wg sync.WaitGroup
    wg.Add(numThreads)

    // 启动多个线程并发访问共享变量
    for i := 0; i < numThreads; i++ {
        go func() {
            defer wg.Done()

            // 获取互斥锁
            mutex.Lock()
            defer mutex.Unlock()

            sharedCount++
            fmt.Printf("Thread %d incremented shared count to %d\n", i, sharedCount)
        }()
    }

    // 等待所有线程完成
    wg.Wait()

    fmt.Printf("Final shared count: %d\n", sharedCount)
}

互斥锁的注意事项

死锁： 如果两个线程相互等待对方释放互斥锁，就会发生死锁。确保互斥锁的使用是公平的，以避免这种情况。
性能开销： 互斥锁会引入一些性能开销，因为它们需要额外的同步操作。明智地使用互斥锁，并根据需要调整其粒度。
粒度： 互斥锁的粒度是指它保护的共享资源的范围。粒度太细会导致过多的同步开销，而粒度太大会降低并发性。

读写锁：高效处理共享数据

读写锁是一种特殊类型的互斥锁，它允许多个线程同时读取共享数据，但只有一个线程可以同时写入共享数据。这对于经常读取而很少写入的数据非常有用，它可以提高并发性同时保持数据的完整性。

读写锁的代码示例

package main

import (
    "fmt"
    "sync"
)

var rwmutex sync.RWMutex
var sharedData string

func main() {
    const numReaders = 5
    const numWriters = 3

    var wg sync.WaitGroup
    wg.Add(numReaders + numWriters)

    // 启动多个线程同时读写共享数据
    for i := 0; i < numReaders; i++ {
        go func() {
            defer wg.Done()

            // 获取读锁
            rwmutex.RLock()
            defer rwmutex.RUnlock()

            fmt.Printf("Reader %d read shared data: %s\n", i, sharedData)
        }()
    }

    for i := 0; i < numWriters; i++ {
        go func() {
            defer wg.Done()

            // 获取写锁
            rwmutex.Lock()
            defer rwmutex.Unlock()

            sharedData += fmt.Sprintf("Writer %d wrote to shared data\n", i)
            fmt.Printf("Writer %d updated shared data to: %s\n", i, sharedData)
        }()
    }

    // 等待所有线程完成
    wg.Wait()
}