Go语言中 Mutex 的实现原理-阿里云开发者社区

在并发编程中，Mutex（互斥锁） 是一种基础的同步机制，用来保护共享资源不被多个 Goroutine 同时访问。Go 标准库中的 sync.Mutex 提供了一种简单而高效的互斥锁实现，广泛应用于多线程程序的并发控制。接下来，我们将深入解析 sync.Mutex 的底层实现原理及其工作机制，帮助你更好地理解和使用它。

1. 什么是 Mutex？

Mutex（互斥锁）是一种并发原语，用于在多线程或多 Goroutine 场景下，确保某一时刻只有一个线程能够访问共享资源。其主要特性是：

互斥性：同一时间只能有一个 Goroutine 获得锁。
阻塞性：如果一个 Goroutine 尝试获取被占用的锁，它将阻塞直到锁被释放。

Go 的 sync.Mutex 提供了三个核心方法：

Lock()：获取锁，如果锁已被占用则阻塞。
Unlock()：释放锁，唤醒等待中的 Goroutine。
Trylock()：尝试获取锁，如果锁已被占用则返回 false。

2. `sync.Mutex` 的数据结构

在 Go 的运行时中，sync.Mutex 是一个轻量级的结构体，其定义如下：

体验AI代码助手

代码解读

复制代码

type Mutex struct {
    state int32  
    sema  uint32
}

字段解释

state：

锁的当前状态，采用一个 32 位的整型值来表示（包括锁标志和 Goroutine 等待数量）。

最低位（bit 0）：锁是否被持有（0未锁定，1锁定）。
次低位（bit 1）：标记是否为饥饿模式（1表示饥饿模式）。
剩余高30位：记录等待锁的goroutine数量。

体验AI代码助手

代码解读

复制代码

  const (
	mutexLocked = 1 << iota // mutex is locked
	mutexWoken
	mutexStarving
	mutexWaiterShift = iota
    starvationThresholdNs = 1e6
  )

sema：

用于 Goroutine 的阻塞和唤醒操作，底层由信号量实现。

3. `sync.Mutex` 的实现原理

3.1 锁的获取 (`Lock()`)

快速路径（Fast Path）

体验AI代码助手

代码解读

复制代码

    // Fast path: grab unlocked mutex.
	if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
		if race.Enabled {
			race.Acquire(unsafe.Pointer(m))
		}
		return
	}

尝试直接获取锁：

使用原子操作atomic.CompareAndSwapInt32（CAS）检查state是否为0。
若成功将state从0变为1（锁未被持有），则直接获取锁，无需其他操作。 race.Enabled 是一个全局变量，由 runtime 管理，当 -race 启用时，它的值为 true，否则为false。也就是说没有启用竞态检测（race.Enabled == false），则跳过这段代码，避免额外的性能开销。

慢速路径（Slow Path）

体验AI代码助手

代码解读

复制代码

func (m *Mutex) lockSlow() {
    // 初始化变量操作，省略...
	for {
        // 这部分处理自旋尝试获取锁的逻辑
		if old&(mutexLocked|mutexStarving) == mutexLocked && runtime_canSpin(iter) {
			 // 省略...
			runtime_doSpin()
			continue
		}
		new := old
        // 如果不是饥饿模式，尝试获取锁(new |= mutexLocked)
		if old&mutexStarving == 0 {
			new |= mutexLocked
		}
        // 如果锁已被占用或处于饥饿模式，增加等待者计数(new += 1 << mutexWaiterShift)
		if old&(mutexLocked|mutexStarving) != 0 {
			new += 1 << mutexWaiterShift
		}
		// 如果当前 goroutine 处于饥饿状态且锁被占用，切换到饥饿模式(new |= mutexStarving)
		if starving && old&mutexLocked != 0 {
			new |= mutexStarving
		}
        // 如果当前 goroutine 是被唤醒的：确保 mutexWoken 标志已设置（否则抛出异常）;清除 mutexWoken 标志(new &^= mutexWoken)
		if awoke {
			if new&mutexWoken == 0 {
				throw("sync: inconsistent mutex state")
			}
			new &^= mutexWoken
		}
        // 尝试用 CAS 更新锁状态
		if atomic.CompareAndSwapInt32(&m.state, old, new) {
			if old&(mutexLocked|mutexStarving) == 0 {
				break 
			}
            // 决定排队位置：如果是第一次等待(waitStartTime == 0)，记录开始等待时间;否则使用 LIFO 顺序(queueLifo = true)
			queueLifo := waitStartTime != 0
			if waitStartTime == 0 {
				waitStartTime = runtime_nanotime()
			}
            // runtime_SemacquireMutex 将 goroutine 放入等待队列并阻塞
			runtime_SemacquireMutex(&m.sema, queueLifo, 2)
            // 被唤醒后：检查是否等待超时（超过 1ms），更新饥饿状态;重新读取锁状态
			starving = starving || runtime_nanotime()-waitStartTime > starvationThresholdNs
			old = m.state
            // 如果是饥饿模式：
			if old&mutexStarving != 0 {
                // 检查状态是否一致
				if old&(mutexLocked|mutexWoken) != 0 || old>>mutexWaiterShift == 0 {
					throw("sync: inconsistent mutex state")
				}
                // 计算状态增量: 设置 mutexLocked;减少等待者计数;如果不再饥饿或只有一个等待者，退出饥饿模式
				delta := int32(mutexLocked - 1<<mutexWaiterShift)
				if !starving || old>>mutexWaiterShift == 1 {
					delta -= mutexStarving
				}
                // 原子更新状态并退出循环
				atomic.AddInt32(&m.state, delta)
				break
			}
			awoke = true
			iter = 0
		} else {
			old = m.state
		}
	}
}

若快速路径失败（锁已被持有），进入慢速路径：

自旋尝试：

若当前是正常模式且锁持有时间较短，当前goroutine会自旋（循环检查锁状态），尝试避免立即阻塞。
自旋条件：多核CPU、当前未处于饥饿模式、等待队列为空或自旋次数未超过阈值。

更新等待计数：

通过原子操作增加state中的等待goroutine计数（高30位）。

进入阻塞或饥饿模式：

正常模式：若自旋失败，将当前goroutine加入信号量等待队列（sema），并调用runtime_SemacquireMutex阻塞。
饥饿模式：若当前goroutine等待时间超过阈值（1ms），触发饥饿模式。此时新来的goroutine直接进入队列尾部，不再自旋。

3.2 锁的释放 (`Unlock()`)

快速释放锁：

体验AI代码助手

代码解读

复制代码

	// Fast path: drop lock bit.
	new := atomic.AddInt32(&m.state, -mutexLocked)

原子操作将state的锁标志位（bit 0）从1置为0。

唤醒等待goroutine：

体验AI代码助手

代码解读

复制代码

old := new
for {
    // 检查是否需要唤醒等待者
    if old>>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken|mutexStarving) != 0 {
        return
    }
    
    // 尝试设置唤醒标志并减少等待者计数
    new = (old - 1<<mutexWaiterShift) | mutexWoken
    if atomic.CompareAndSwapInt32(&m.state, old, new) {
        runtime_Semrelease(&m.sema, false, 2)
        return
    }
    old = m.state
}

体验AI代码助手

代码解读

复制代码

else {
    // 饥饿模式：直接将锁交给下一个等待者
    runtime_Semrelease(&m.sema, true, 2)
}

若有等待的goroutine：

正常模式：唤醒队列头部的goroutine，并允许新goroutine与其竞争锁。
饥饿模式：直接将锁交给队列头部的goroutine，确保公平性（避免新goroutine“插队”）。

4. 关键优化点

4.1 自旋锁优化

Go 的 sync.Mutex 在竞争不激烈时，会采用短暂的 自旋锁 机制。自旋锁允许 Goroutine 在一小段时间内忙等待，而不是立即进入阻塞状态。这种策略避免了频繁的上下文切换开销。

自旋锁的具体表现：

如果锁短时间内会被释放，Goroutine 会进行自旋尝试再次获取锁。
如果尝试失败，才会进入阻塞状态。

4.2 信号量机制

对于被阻塞的 Goroutines，sync.Mutex 使用了基于信号量的等待和唤醒机制：

等待：调用 runtime_SemacquireMutex()，将当前 Goroutine 放入等待队列并阻塞。
唤醒：调用 runtime_Semrelease()，唤醒一个等待中的 Goroutine。

5. 示例流程

场景：正常模式下的锁竞争

#bytemd-mermaid-1747115856147-0{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#bytemd-mermaid-1747115856147-0 .error-icon{fill:#552222;}#bytemd-mermaid-1747115856147-0 .error-text{fill:#552222;stroke:#552222;}#bytemd-mermaid-1747115856147-0 .edge-thickness-normal{stroke-width:2px;}#bytemd-mermaid-1747115856147-0 .edge-thickness-thick{stroke-width:3.5px;}#bytemd-mermaid-1747115856147-0 .edge-pattern-solid{stroke-dasharray:0;}#bytemd-mermaid-1747115856147-0 .edge-pattern-dashed{stroke-dasharray:3;}#bytemd-mermaid-1747115856147-0 .edge-pattern-dotted{stroke-dasharray:2;}#bytemd-mermaid-1747115856147-0 .marker{fill:#333333;stroke:#333333;}#bytemd-mermaid-1747115856147-0 .marker.cross{stroke:#333333;}#bytemd-mermaid-1747115856147-0 svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#bytemd-mermaid-1747115856147-0 .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#bytemd-mermaid-1747115856147-0 .cluster-label text{fill:#333;}#bytemd-mermaid-1747115856147-0 .cluster-label span{color:#333;}#bytemd-mermaid-1747115856147-0 .label text,#bytemd-mermaid-1747115856147-0 span{fill:#333;color:#333;}#bytemd-mermaid-1747115856147-0 .node rect,#bytemd-mermaid-1747115856147-0 .node circle,#bytemd-mermaid-1747115856147-0 .node ellipse,#bytemd-mermaid-1747115856147-0 .node polygon,#bytemd-mermaid-1747115856147-0 .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#bytemd-mermaid-1747115856147-0 .node .label{text-align:center;}#bytemd-mermaid-1747115856147-0 .node.clickable{cursor:pointer;}#bytemd-mermaid-1747115856147-0 .arrowheadPath{fill:#333333;}#bytemd-mermaid-1747115856147-0 .edgePath .path{stroke:#333333;stroke-width:2.0px;}#bytemd-mermaid-1747115856147-0 .flowchart-link{stroke:#333333;fill:none;}#bytemd-mermaid-1747115856147-0 .edgeLabel{background-color:#e8e8e8;text-align:center;}#bytemd-mermaid-1747115856147-0 .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#bytemd-mermaid-1747115856147-0 .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#bytemd-mermaid-1747115856147-0 .cluster text{fill:#333;}#bytemd-mermaid-1747115856147-0 .cluster span{color:#333;}#bytemd-mermaid-1747115856147-0 div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#bytemd-mermaid-1747115856147-0 .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#bytemd-mermaid-1747115856147-0 :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}

快速路径成功

快速路径失败

自旋失败

完成工作

B获胜

C获胜

Goroutine A Lock

持有锁

Goroutine B Lock尝试

进入慢路径

自旋尝试

增加等待计数, 进入队列阻塞

Goroutine A Unlock

唤醒Goroutine B

新Goroutine C到达

Goroutine B和C竞争锁

Goroutine B获得锁

Goroutine C获得锁

Goroutine A 获取锁（Lock()快速路径成功）。
Goroutine B 尝试获取锁，进入慢速路径：

自旋数次后失败，增加等待计数，进入队列阻塞。

Goroutine A 释放锁（Unlock()）：

唤醒Goroutine B，新来的Goroutine C可与B竞争锁。

场景：饥饿模式下的锁竞争

#bytemd-mermaid-1747115856274-1{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#bytemd-mermaid-1747115856274-1 .error-icon{fill:#552222;}#bytemd-mermaid-1747115856274-1 .error-text{fill:#552222;stroke:#552222;}#bytemd-mermaid-1747115856274-1 .edge-thickness-normal{stroke-width:2px;}#bytemd-mermaid-1747115856274-1 .edge-thickness-thick{stroke-width:3.5px;}#bytemd-mermaid-1747115856274-1 .edge-pattern-solid{stroke-dasharray:0;}#bytemd-mermaid-1747115856274-1 .edge-pattern-dashed{stroke-dasharray:3;}#bytemd-mermaid-1747115856274-1 .edge-pattern-dotted{stroke-dasharray:2;}#bytemd-mermaid-1747115856274-1 .marker{fill:#333333;stroke:#333333;}#bytemd-mermaid-1747115856274-1 .marker.cross{stroke:#333333;}#bytemd-mermaid-1747115856274-1 svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#bytemd-mermaid-1747115856274-1 .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#bytemd-mermaid-1747115856274-1 .cluster-label text{fill:#333;}#bytemd-mermaid-1747115856274-1 .cluster-label span{color:#333;}#bytemd-mermaid-1747115856274-1 .label text,#bytemd-mermaid-1747115856274-1 span{fill:#333;color:#333;}#bytemd-mermaid-1747115856274-1 .node rect,#bytemd-mermaid-1747115856274-1 .node circle,#bytemd-mermaid-1747115856274-1 .node ellipse,#bytemd-mermaid-1747115856274-1 .node polygon,#bytemd-mermaid-1747115856274-1 .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#bytemd-mermaid-1747115856274-1 .node .label{text-align:center;}#bytemd-mermaid-1747115856274-1 .node.clickable{cursor:pointer;}#bytemd-mermaid-1747115856274-1 .arrowheadPath{fill:#333333;}#bytemd-mermaid-1747115856274-1 .edgePath .path{stroke:#333333;stroke-width:2.0px;}#bytemd-mermaid-1747115856274-1 .flowchart-link{stroke:#333333;fill:none;}#bytemd-mermaid-1747115856274-1 .edgeLabel{background-color:#e8e8e8;text-align:center;}#bytemd-mermaid-1747115856274-1 .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#bytemd-mermaid-1747115856274-1 .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#bytemd-mermaid-1747115856274-1 .cluster text{fill:#333;}#bytemd-mermaid-1747115856274-1 .cluster span{color:#333;}#bytemd-mermaid-1747115856274-1 div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#bytemd-mermaid-1747115856274-1 .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#bytemd-mermaid-1747115856274-1 :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}

完成工作

否

是

Goroutine B等待>1ms

触发饥饿模式

新Goroutine C到达

直接进入队列尾部

Goroutine A Unlock

直接将锁交给队列头部的B

Goroutine B持有锁

Goroutine B Unlock

队列中是否有等待者?

清除饥饿标志
退出饥饿模式

保持饥饿模式
继续交给下一个等待者

Goroutine B 等待超过1ms，触发饥饿模式。
Goroutine C 新到达，直接进入队列尾部，不自旋。
Goroutine A 释放锁：

直接将锁交给队列头部的Goroutine B。

Goroutine B 释放锁后，若队列中无等待者，退出饥饿模式。

6. 总结

Go 的 sync.Mutex 是一个简单而强大的并发原语，它通过低级别的 CAS 和信号量机制，实现了高效的线程安全。其设计特点包括：原子操作与自旋：减少短锁持有场景的上下文切换。信号量与等待队列：管理长时间竞争的goroutine。饥饿模式：防止goroutine无限期等待，确保公平性。

转载来源：https://juejin.cn/post/7488246529430487077

Go语言中 Mutex 的实现原理

1. 什么是 Mutex？

2. `sync.Mutex` 的数据结构

字段解释

3. `sync.Mutex` 的实现原理

3.1 锁的获取 (`Lock()`)

快速路径（Fast Path）

慢速路径（Slow Path）

3.2 锁的释放 (`Unlock()`)

4. 关键优化点

4.1 自旋锁优化

4.2 信号量机制

5. 示例流程

场景：正常模式下的锁竞争

场景：饥饿模式下的锁竞争

6. 总结

热门文章

最新文章

相关课程

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

Go语言中 Mutex 的实现原理

1. 什么是 Mutex？

2. sync.Mutex 的数据结构

字段解释

3. sync.Mutex 的实现原理

3.1 锁的获取 (Lock())

快速路径（Fast Path）

慢速路径（Slow Path）

3.2 锁的释放 (Unlock())

4. 关键优化点

4.1 自旋锁优化

4.2 信号量机制

5. 示例流程

场景：正常模式下的锁竞争

场景：饥饿模式下的锁竞争

6. 总结

热门文章

最新文章

相关课程

相关电子书

2. `sync.Mutex` 的数据结构

3. `sync.Mutex` 的实现原理

3.1 锁的获取 (`Lock()`)

3.2 锁的释放 (`Unlock()`)