Go 并发 Goroutine 间的互斥执行详解

本文旨在详细讲解如何在 Go 语言中实现并发 Goroutine 之间的互斥执行。通过使用互斥锁（Mutex），可以确保在特定代码块执行期间，其他 Goroutine 不会被调度，从而避免数据竞争和死锁等问题。文章将提供代码示例，并深入探讨互斥锁的使用方法和注意事项，帮助开发者更好地理解和应用并发编程技术。

在并发编程中，多个 Goroutine 同时访问和修改共享资源时，可能会出现数据竞争的问题。为了避免这种情况，我们需要确保在访问共享资源时进行互斥操作，即同一时刻只能有一个 Goroutine 访问该资源。Go 语言提供了 sync.Mutex 类型来实现互斥锁，可以有效地解决并发访问问题。

使用 Mutex 实现互斥

sync.Mutex 提供了 Lock() 和 Unlock() 方法，分别用于获取锁和释放锁。当一个 Goroutine 调用 Lock() 方法时，如果锁当前未被占用，则该 Goroutine 获得锁，可以继续执行；如果锁已被其他 Goroutine 占用，则该 Goroutine 会阻塞，直到锁被释放。当 Goroutine 完成对共享资源的访问后，应调用 Unlock() 方法释放锁，以便其他 Goroutine 可以获取锁。

以下是一个简单的示例，演示了如何使用 sync.Mutex 来保护共享资源：

package main

import (
    "fmt"
    "sync"
    "time"
)

var (
    counter int
    mutex   sync.Mutex
)

func increment() {
    for i := 0; i < 1000; i++ {
        mutex.Lock() // 获取锁
        counter++
        mutex.Unlock() // 释放锁
        time.Sleep(time.Millisecond) // 模拟耗时操作
    }
}

func main() {
    go increment()
    go increment()

    time.Sleep(3 * time.Second) // 等待 Goroutine 执行完成

    fmt.Println("Counter:", counter)
}

在上面的示例中，counter 是一个共享变量，多个 Goroutine 会同时对其进行递增操作。为了避免数据竞争，我们使用 mutex.Lock() 和 mutex.Unlock() 方法来保护 counter++ 这行代码。这样，在任何时刻，只有一个 Goroutine 能够执行递增操作，从而保证了数据的正确性。

注意事项

在使用 sync.Mutex 时，需要注意以下几点：

PhotoAid Image Upscaler

PhotoAid出品的免费在线AI图片放大工具

52

查看详情

1. 必须成对调用 Lock() 和 Unlock() 方法。 如果只调用 Lock() 方法而不调用 Unlock() 方法，会导致锁一直被占用，其他 Goroutine 永远无法获取锁，从而造成死锁。
2. Unlock() 方法只能由获取锁的 Goroutine 调用。 如果在未获取锁的情况下调用 Unlock() 方法，或者由其他 Goroutine 调用 Unlock() 方法，会导致运行时错误。
3. 可以使用 defer 语句来确保锁被释放。 为了避免忘记调用 Unlock() 方法，可以使用 defer 语句来延迟执行 Unlock() 方法。这样，即使在函数执行过程中发生错误，Unlock() 方法也会被调用，从而避免死锁。例如：

func increment() {
    for i := 0; i < 1000; i++ {
        mutex.Lock()
        defer mutex.Unlock() // 确保锁被释放
        counter++
        time.Sleep(time.Millisecond)
    }
}

使用 RWMutex 实现读写锁

在某些情况下，多个 Goroutine 可以同时读取共享资源，但只有一个 Goroutine 可以写入共享资源。在这种情况下，可以使用 sync.RWMutex 来实现读写锁。RWMutex 提供了 RLock() 和 RUnlock() 方法用于获取读锁和释放读锁，Lock() 和 Unlock() 方法用于获取写锁和释放写锁。

以下是一个简单的示例，演示了如何使用 sync.RWMutex 来实现读写锁：

package main

import (
    "fmt"
    "sync"
    "time"
)

var (
    data  string
    rwMutex sync.RWMutex
)

func readData() {
    rwMutex.RLock() // 获取读锁
    defer rwMutex.RUnlock() // 释放读锁
    fmt.Println("Read Data:", data)
    time.Sleep(time.Millisecond * 100)
}

func writeData(newData string) {
    rwMutex.Lock() // 获取写锁
    defer rwMutex.Unlock() // 释放写锁
    data = newData
    fmt.Println("Write Data:", data)
    time.Sleep(time.Millisecond * 200)
}

func main() {
    go readData()
    go readData()
    go writeData("Hello")
    go readData()
    go writeData("World")

    time.Sleep(time.Second)
}

在上面的示例中，readData() 函数获取读锁，可以同时被多个 Goroutine 调用；writeData() 函数获取写锁，只能被一个 Goroutine 调用。这样，可以提高并发程序的性能，同时保证数据的正确性。

总结

sync.Mutex 和 sync.RWMutex 是 Go 语言中常用的并发控制工具，可以有效地避免数据竞争和死锁等问题。在使用它们时，需要注意成对调用 Lock() 和 Unlock() 方法，并使用 defer 语句来确保锁被释放。理解并掌握互斥锁的使用方法，是编写高效、可靠的并发程序的关键。

以上就是Go 并发 Goroutine 间的互斥执行详解的详细内容，更多请关注php中文网其它相关文章！