Golang如何使用sync.Mutex实现互斥锁_Golang Mutex互斥锁实践-Golang-PHP中文网

使用mutex可防止多个goroutine并发访问共享资源导致数据竞争，确保临界区的原子性，避免因操作交错引发结果错误。

golang如何使用sync.mutex实现互斥锁_golang mutex互斥锁实践

在Go语言中，sync.Mutex 是最常用的同步原语之一，用于保护共享资源，防止多个goroutine同时访问造成数据竞争。当多个并发任务需要修改同一变量或结构时，使用互斥锁能确保在同一时刻只有一个goroutine可以进入临界区。

为什么需要Mutex？

Go的并发模型基于goroutine和channel，但当多个goroutine同时读写同一个变量时，比如一个计数器，就会出现竞态条件（race condition）。即使看似简单的操作如 count++，实际上包含“读-改-写”三个步骤，在并发下可能交错执行，导致结果错误。

例如：

var count = 0
for i := 0; i 
<p>如果不加保护，最终的 <font face="Courier New">count</font> 值很可能小于1000。</p>

<h3>如何使用sync.Mutex加锁</h3>
<p>通过在访问共享资源前调用 <font face="Courier New">Lock()</font>，使用完后调用 <font face="Courier New">Unlock()</font>，即可保证临界区的互斥执行。</p>

<p>示例：安全的计数器</p>
<pre class="brush:php;toolbar:false;">package main

import (
    "fmt"
    "sync"
)

var (
    count = 0
    mu    sync.Mutex
)

func main() {
    var wg sync.WaitGroup

    for i := 0; i 
<p>这里使用 <font face="Courier New">defer mu.Unlock()</font> 确保即使发生panic也能释放锁，避免死锁。</p><div class="aritcle_card flexRow artxards">
											<div class="artcardd flexRow">
												<a class="aritcle_card_img" rel="nofollow" href="/xiazai/gongju/2525" title="Go语言（Golang）1.26.0"><img
														src="https://img.php.cn/upload/manual/001/589/237/6a6adeed24a4a355.png" alt="Go语言（Golang）1.26.0" onerror="this.onerror='';this.src='/static/lhimages/moren/morentu.png'" ></a>
												<div class="aritcle_card_info flexColumn">
													<a rel="nofollow" href="/xiazai/gongju/2525" title="Go语言（Golang）1.26.0" class="overflowclass">Go语言（Golang）1.26.0</a>
													<p class="overflowclass">Go语言（Golang）1.26.0版本官方下载，版本号 1.26.0，适合旧项目维护、兼容性测试和指定版本开发环境搭建。</p>
												</div>
												<a rel="nofollow" href="/xiazai/gongju/2525" title="Go语言（Golang）1.26.0" class="aritcle_card_btn flexRow flexcenter"><b></b><span>下载</span>
												</a>
											</div>
										</div>

<h3>常见使用模式与注意事项</h3>

成对使用Lock/Unlock：务必确保每次Lock后都有对应的Unlock，推荐使用defer。
不要复制包含Mutex的结构体：复制会导致锁状态丢失，引发未定义行为。
避免重入死锁：Go的Mutex不支持递归锁，同一个goroutine重复加锁会死锁。
粒度适中：锁的范围不宜过大，否则影响并发性能；也不宜过小，增加管理复杂度。

结构体内嵌Mutex的典型做法：

type Counter struct {
    mu    sync.Mutex
    value int
}

func (c *Counter) Inc() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.value++
}

func (c *Counter) Value() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.value
}

这样对外暴露的方法都是线程安全的。

RWMutex：读写场景优化

如果共享资源主要是读操作，偶尔写入，使用 sync.RWMutex 更高效。

RLock()/RUnlock()：允许多个读并发。
Lock()/Unlock()：写操作独占。

示例：

var (
    data = make(map[string]int)
    rwmu sync.RWMutex
)

func read(key string) int {
    rwmu.RLock()
    defer rwmu.RUnlock()
    return data[key]
}

func write(key string, val int) {
    rwmu.Lock()
    defer rwmu.Unlock()
    data[key] = val
}

多个goroutine可同时调用read，但write会阻塞所有读写。

基本上就这些。合理使用Mutex能有效避免并发问题，关键是理解临界区范围，正确加锁解锁，避免死锁和复制。实际开发中结合go run -race检测竞态，能大幅提升程序稳定性。