Go语言并发安全与锁机制详解：互斥锁与读写锁实战

雨后青山

发布时间：2026-10-13| 5人浏览过

原创

在Go语言开发中，多个Goroutine同时访问和修改共享变量会导致数据竞争（Data Race），产生不可预期的结果。本文通过实例展示并发安全问题，并深入解析互斥锁与读写锁的代码实现及使用场景。

并发安全：数据竞争的根源

当两个或多个Goroutine同时访问同一个变量，且至少有一个尝试修改该变量时，就会发生数据竞争。以下代码展示了这一典型问题：

package main

import (
	"fmt"
	"sync"
)

var (
	sum int
	wg  sync.WaitGroup
)

func test() {
	for i := 0; i < 5000000; i++ {
		sum += 1
	}
	wg.Done()
}

func main() {
	// 启动两个协程并发累加
	wg.Add(2)
	go test()
	go test()

	wg.Wait()
	fmt.Println(sum)
}

在上述示例中，test函数被两个Goroutine并行执行。由于sum += 1并非原子操作（包含读取、计算、写入三个步骤），高并发下会出现“丢失更新”现象。最终输出的sum值往往远小于预期的10000000，这就是并发不安全导致的后果。

解决方案一：使用互斥锁保障临界区

为确保数据安全，需引入互斥锁（Mutex）。sync.Mutex能确保同一时刻仅有一个Goroutine进入临界区操作共享资源，其他等待者需独占等待，直到锁释放。

package main

import (
	"fmt"
	"sync"
)

var (
	sum  int
	wg   sync.WaitGroup
	mu   sync.Mutex // 定义互斥锁
)

func test() {
	for i := 0; i < 10000000; i++ {
		mu.Lock()      // 获取锁
		sum += 1       // 临界区操作
		mu.Unlock()    // 释放锁
	}
	wg.Done()
}

func main() {
	wg.Add(2)
	go test()
	go test()

	wg.Wait()
	fmt.Println(sum) // 输出固定为 20000000
}

关键注意点：

成对使用：Lock()和Unlock()必须严格配对，通常推荐使用defer mu.Unlock()避免死锁。
唤醒机制：多个Goroutine等待同一把锁时，唤醒策略是随机的（Fairness不保证）。
适用场景：适用于写多或读写比例均衡的场景。

解决方案二：读写锁优化读多写少场景

若业务场景中“读”的操作远多于“写”，互斥锁的性能瓶颈在于它将所有的读操作也变成了串行。此时应使用sync.RWMutex（读写互斥锁）。

第1步：理解读写锁机制

读写锁将锁分为两种模式：
- 读锁（RLock）：可被多个Goroutine同时持有。只要有人持读锁，其他人仍可获取读锁；但写锁必须等待所有读锁释放。
- 写锁（Lock）：具有排他性。一旦获取写锁，其他所有读锁和写锁均须等待，直到写锁释放。

第2步：代码实现与性能对比

以下代码模拟了并发读取与写入的过程：

package main

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

var (
	x     int
	wg    sync.WaitGroup
	mu    sync.Mutex
	rw    sync.RWMutex // 读写锁
)

func write() {
	rw.Lock()
	x += 1
	time.Sleep(10 * time.Millisecond) // 模拟耗时写入
	rw.Unlock()
	wg.Done()
}

func read() {
	rw.RLock()
	time.Sleep(time.Millisecond) // 模拟耗时读取
	rw.RUnlock()
	wg.Done()
}

func main() {
	start := time.Now()
	
	// 执行10次写入
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go write()
	}
	
	// 执行1000次读取
	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go read()
	}
	
	wg.Wait()
	end := time.Now()
	fmt.Printf("总耗时: %v\n", end.Sub(start))
}

性能分析：
在上述测试中，写入操作因持有写锁而串行执行，耗时长；而1000个读取操作因可并行持有读锁，几乎并发完成。实验显示，读写锁在读多写少（如1:100）时，性能优势显著（例如耗时从数秒降至几十毫秒）。但如果读写比例接近，其加解锁的管理开销反而可能低于简单的互斥锁。