Go 并发安全与读写互斥锁实战详解

Finn

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

原创

在 Go 语言开发中，多 goroutine 同时访问共享资源容易引发数据竞态。本文详细解析如何使用互斥锁（Mutex）保证基础的安全访问，以及在“读多写少”场景下如何利用读写锁（RWMutex）优化并发性能，附带完整的代码示例。

理解并发竞态问题

当多个 goroutine 同时操作同一个资源（临界区）时，可能会发生竞态问题（Data Race）。这类似于十字路口不同方向的汽车争夺通行权，或火车车厢内多人争用卫生间的场景。若不加控制，最终结果往往与预期不符。

以下是一个典型的竞态示例：两个 goroutine 同时累加全局变量 x，由于缺乏同步机制，最终输出的值通常小于预期的 10000。

var x int64
var wg sync.WaitGroup

func add() {
	for i := 0; i < 5000; i++ {
		x = x + 1 // 存在数据竞争
	}
	wg.Done()
}

func main() {
	wg.Add(2)
	go add()
	go add()
	wg.Wait()
	fmt.Println(x) // 结果不确定，通常不为 10000
}

第一步：使用互斥锁保护临界区

互斥锁（sync.Mutex）是 Go 标准库中最基础的同步原语，它保证同一时刻只有一个 goroutine 能进入临界区。其他请求锁的 goroutine 将被阻塞，直到锁被释放。获取锁的策略通常是随机的，以防止优先级反转。

第 1 步：引入 sync.Mutex 并定义变量

首先需要在 main 包中导入 sync 包，并声明一个全局的 Mutex 实例作为守卫者。

第 2 步：在临界区前后调用 Lock 和 Unlock

在每个 goroutine 修改变量前调用 Lock()，修改完成后立即调用 Unlock()。这确保了累加操作的原子性。

var (
	x      int64
	wg     sync.WaitGroup
	lock   sync.Mutex
)

func add() {
	for i := 0; i < 5000; i++ {
		lock.Lock()   // 加锁：只有当前 goroutine 持有锁时才能执行后续代码
		x = x + 1     // 临界区操作
		lock.Unlock() // 解锁：允许其他等待的 goroutine 获取锁
	}
	wg.Done()
}

func main() {
	wg.Add(2)
	go add()
	go add()
	wg.Wait()
	fmt.Println(x) // 输出确定值为 10000
}

注意：Lock 和 Unlock 必须成对出现。在实际工程中，建议将 Unlock 放在 defer 块中，以防函数提前返回导致死锁。

第二步：使用读写锁优化读多写少场景

互斥锁是完全互斥的，即便只是读取共享资源，也会阻止其他读取者。但在实际应用中，很多场景是“读多写少”。例如缓存查询、配置加载等。此时，使用读写锁（sync.RWMutex）可以显著提升并发吞吐量。

读写锁分为两种模式：

读锁（RLock/RUnlock）：允许同时被多个 goroutine 获取。只要没有写锁，读锁之间不互斥。
写锁（Lock/Unlock）：独占模式。一旦获取写锁，其他所有读锁和写锁都必须等待。

第 1 步：切换至 sync.RWMutex

将之前的 sync.Mutex 替换为 sync.RWMutex，并根据操作类型选择相应的加锁方法。

第 2 步：实现读写分离逻辑

在写入操作时使用 rwlock.Lock()，在读操作时使用 rwlock.RLock()。这样可以使多个读取者并行执行，而写入时保持排他。

var (
	x       int64
	wg      sync.WaitGroup
	rwlock  sync.RWMutex
)

func write() {
	rwlock.Lock()      // 加写锁
	x = x + 1          // 写入操作
	time.Sleep(10 * time.Millisecond) // 模拟耗时
	rwlock.Unlock()    // 释放写锁
	wg.Done()
}

func read() {
	rwlock.RLock()     // 加读锁
	_ = x              // 读取操作
	time.Sleep(time.Millisecond)       // 模拟耗时
	rwlock.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))
}

性能提示：如果读写频率相当，读写锁的上下文切换开销可能使其不如普通互斥锁高效。因此，应仅在确认“读远多于写”的场景下使用。