Go 并发编程中的互斥执行-Golang-PHP中文网

Go 并发编程中的互斥执行

聖光之護

发布： 2025-08-17 22:44:13

原创

715人浏览过

go 并发编程中的互斥执行

在 Go 语言的并发编程中，控制对共享资源的访问是至关重要的。为了保证数据的一致性和程序的正确性，我们需要确保在同一时刻只有一个 goroutine 可以访问特定的代码段，这个代码段通常被称为临界区。虽然 Go 提供了强大的并发原语，例如 channels，但在某些情况下，使用互斥锁（mutex）仍然是解决并发问题的有效手段。

使用 sync.Mutex 实现互斥

sync.Mutex 是 Go 语言标准库 sync 包中提供的互斥锁。它提供了 Lock() 和 Unlock() 两个方法，分别用于获取锁和释放锁。当一个 goroutine 调用 Lock() 方法时，如果锁当前未被其他 goroutine 持有，则该 goroutine 成功获取锁并继续执行；否则，该 goroutine 将阻塞，直到锁被释放。当 goroutine 完成对临界区的访问后，必须调用 Unlock() 方法释放锁，以便其他 goroutine 可以获取锁。

以下是一个使用 sync.Mutex 的示例：

package main

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

var (
    mutex   sync.Mutex
    counter int
)

func incrementCounter(id int, wg *sync.WaitGroup) {
    defer wg.Done()

    for i := 0; i < 1000; i++ {
        mutex.Lock() // 获取锁
        counter++
        fmt.Printf("Goroutine %d: Counter = %d\n", id, counter) // 临界区
        mutex.Unlock() // 释放锁
        time.Sleep(time.Millisecond) // 模拟一些工作
    }
}

func main() {
    var wg sync.WaitGroup

    wg.Add(2)
    go incrementCounter(1, &wg)
    go incrementCounter(2, &wg)

    wg.Wait()
    fmt.Println("Final Counter Value:", counter)
}

登录后复制

在这个例子中，incrementCounter 函数模拟了一个需要访问共享变量 counter 的 goroutine。为了防止多个 goroutine 同时修改 counter 导致数据竞争，我们使用 mutex.Lock() 和 mutex.Unlock() 包裹了对 counter 的访问。这样，在任何时刻，只有一个 goroutine 能够修改 counter 的值。

最佳实践：优先使用 Go Channels

虽然 sync.Mutex 可以有效地保护临界区，但在 Go 语言中，通常推荐使用 Go channels 来实现并发控制。Channels 提供了一种更加安全和简洁的方式来传递数据和同步 goroutine，可以有效地避免数据竞争和死锁等问题。

豆包AI编程

豆包推出的AI编程助手

483

查看详情

以下是一个使用 channels 实现相同功能的示例：

package main

import (
    "fmt"
    "sync"
)

func main() {
    counter := 0
    iterations := 1000
    numGoroutines := 2

    increment := make(chan int, numGoroutines*iterations) // Buffered channel
    var wg sync.WaitGroup
    wg.Add(numGoroutines)

    // Launch goroutines to increment the counter
    for i := 0; i < numGoroutines; i++ {
        go func(id int) {
            defer wg.Done()
            for j := 0; j < iterations; j++ {
                increment <- 1 // Send a signal to increment
                fmt.Printf("Goroutine %d: increment signal sent\n", id)
            }
        }(i + 1)
    }

    // Launch a goroutine to sum up the increments
    go func() {
        for i := 0; i < numGoroutines*iterations; i++ {
            counter += <-increment // Receive an increment signal
            fmt.Printf("Sum: Counter = %d\n", counter)
        }
    }()

    wg.Wait()
    fmt.Println("Final Counter Value:", counter)
}

登录后复制

在这个例子中，我们使用一个 buffered channel increment 来传递递增的信号。每个 goroutine 将递增信号发送到 channel 中，而另一个 goroutine 则从 channel 中接收信号并更新计数器。通过使用 channel，我们避免了显式地使用互斥锁，从而简化了代码并提高了程序的安全性。

注意事项

避免死锁： 在使用 sync.Mutex 时，务必小心避免死锁。死锁是指两个或多个 goroutine 互相等待对方释放锁，导致程序无法继续执行的情况。
及时释放锁： 在获取锁后，务必确保在退出临界区时释放锁，即使发生错误也应该释放锁，可以使用 defer 语句来确保锁被释放。
优先使用 Channels： 在设计并发程序时，应该优先考虑使用 Go channels 来实现并发控制，只有在确实需要使用互斥锁的情况下才使用 sync.Mutex。

总结

sync.Mutex 是 Go 语言中用于保护临界区的互斥锁。通过使用 Lock() 和 Unlock() 方法，可以确保在同一时刻只有一个 goroutine 可以访问共享资源。然而，在设计并发程序时，应该优先考虑使用 Go channels 来实现并发控制，以提高程序的安全性、可读性和可维护性。只有在确实需要使用互斥锁的情况下才使用 sync.Mutex，并务必小心避免死锁。

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