Go并发编程中sync.Mutex锁失效的原因是什么？

对于一个Golang开发者来说，牢固扎实的基础是十分重要的，golang学习网就来带大家一点点的掌握基础知识点。今天本篇文章带大家了解《Go并发编程中sync.Mutex锁失效的原因是什么？》，主要介绍了，希望对大家的知识积累有所帮助，快点收藏起来吧，否则需要时就找不到了！

Go并发编程中sync.Mutex锁失效原因及排查

本文分析一个使用sync.Mutex和sync.WaitGroup进行并发计数的例子，解释为什么程序结果并非预期的1000，以及如何解决。目标是利用1000个协程对变量进行1000次加1操作，期望结果为1000，但实际结果却随机。

问题代码示例：

package main

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

func main() {
    hasLockAndWait()
}

func hasLockAndWait() {
    var a = 0
    var wg sync.WaitGroup

    for i := 0; i < 1000; i++ {
        locker := &sync.Mutex{} // 错误：每个协程拥有独立的锁
        wg.Add(1)
        go func(i int, locker *sync.Mutex) {
            defer wg.Done()
            locker.Lock()
            a++
            locker.Unlock()
        }(i, locker)
    }
    wg.Wait()
    fmt.Println("最终结果:", a)
}

问题根源：

代码中，每个协程都创建了一个独立的sync.Mutex实例locker。这就是问题所在，每个协程拥有自己的锁，它们互不干扰。因此，多个协程可以同时对变量a进行操作，导致最终结果不正确。

解决方案：

将var locker sync.Mutex声明移到for循环外部，使所有协程共享同一个sync.Mutex实例，从而确保同一时刻只有一个协程可以访问并修改变量a。 修改后的代码如下：

package main

import (
    "fmt"
    "sync"
)

func main() {
    hasLockAndWait()
}

func hasLockAndWait() {
    var a = 0
    var wg sync.WaitGroup
    var locker sync.Mutex // 正确：所有协程共享同一个锁

    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            locker.Lock()
            a++
            locker.Unlock()
        }(i)
    }
    wg.Wait()
    fmt.Println("最终结果:", a)
}

更优解决方案：使用原子操作

更简洁高效的解决方法是使用atomic.AddInt64()函数，它提供原子操作，无需使用锁即可保证并发安全，避免了锁的开销，提高了程序性能。

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
)

func main() {
    var a int64
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            atomic.AddInt64(&a, 1)
        }()
    }
    wg.Wait()
    fmt.Println("最终结果:", a)
}

通过以上修改，程序将正确输出1000。 选择哪种方法取决于具体需求和性能考量，但原子操作通常是更优的选择，除非需要更复杂的同步机制。

好了，本文到此结束，带大家了解了《Go并发编程中sync.Mutex锁失效的原因是什么？》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！