Go语言中 Mutex 的实现原理

于 2025-05-13 13:59:12 发布
阅读量54 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： golang 开发语言 后端
原文链接：https://juejin.cn/post/7488246529430487077

在并发编程中，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 是一个轻量级的结构体，其定义如下：

go

体验AI代码助手

代码解读

复制代码

type Mutex struct { state int32 sema uint32 }

字段解释

  1. state：
    • 锁的当前状态，采用一个 32 位的整型值来表示（包括锁标志和 Goroutine 等待数量）。
  • 最低位（bit 0）：锁是否被持有（0未锁定，1锁定）。
  • 次低位（bit 1）：标记是否为饥饿模式（1表示饥饿模式）。
  • 剩余高30位：记录等待锁的goroutine数量。

go

体验AI代码助手

代码解读

复制代码

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

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

3. sync.Mutex 的实现原理

3.1 锁的获取 (Lock())

快速路径（Fast Path）

go

体验AI代码助手

代码解读

复制代码

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

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

go

体验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 } } }

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

  1. 自旋尝试：
    • 若当前是正常模式且锁持有时间较短，当前goroutine会自旋（循环检查锁状态），尝试避免立即阻塞。
    • 自旋条件：多核CPU、当前未处于饥饿模式、等待队列为空或自旋次数未超过阈值。
  2. 更新等待计数：
    • 通过原子操作增加state中的等待goroutine计数（高30位）。
  3. 进入阻塞或饥饿模式：
    • 正常模式：若自旋失败，将当前goroutine加入信号量等待队列（sema），并调用runtime_SemacquireMutex阻塞。
    • 饥饿模式：若当前goroutine等待时间超过阈值（1ms），触发饥饿模式。此时新来的goroutine直接进入队列尾部，不再自旋。

3.2 锁的释放 (Unlock())

  1. 快速释放锁：

go

体验AI代码助手

代码解读

复制代码

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

  • 原子操作将state的锁标志位（bit 0）从1置为0。
  1. 唤醒等待goroutine：

go

体验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 }

go

体验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. 示例流程

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

快速路径成功

快速路径失败

自旋失败

完成工作

B获胜

C获胜

Goroutine A Lock

持有锁

Goroutine B Lock尝试

进入慢路径

自旋尝试

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

Goroutine A Unlock

唤醒Goroutine B

新Goroutine C到达

Goroutine B和C竞争锁

Goroutine B获得锁

Goroutine C获得锁

  1. Goroutine A 获取锁（Lock()快速路径成功）。
  2. Goroutine B 尝试获取锁，进入慢速路径：
    • 自旋数次后失败，增加等待计数，进入队列阻塞。
  3. Goroutine A 释放锁（Unlock()）：
    • 唤醒Goroutine B，新来的Goroutine C可与B竞争锁。

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

完成工作

否

是

Goroutine B等待>1ms

触发饥饿模式

新Goroutine C到达

直接进入队列尾部

Goroutine A Unlock

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

Goroutine B持有锁

Goroutine B Unlock

队列中是否有等待者?

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

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

  1. Goroutine B 等待超过1ms，触发饥饿模式。
  2. Goroutine C 新到达，直接进入队列尾部，不自旋。
  3. Goroutine A 释放锁：
    • 直接将锁交给队列头部的Goroutine B。
  4. Goroutine B 释放锁后，若队列中无等待者，退出饥饿模式。

6. 总结

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

深入剖析Golang领域Mutex的实现原理
Golang编程笔记的博客
05-24 738
Golang以“原生支持高并发”著称，但并发编程中最棘手的问题是共享资源竞争（比如多个Goroutine同时修改一个变量）。Mutex作为解决这一问题的核心工具，其内部实现融合了对性能、公平性、调度器的深度优化。本文将聚焦版本的MutexMutex的核心数据结构与状态表示Lock()和Unlock()的执行流程正常模式与饥饿模式的切换逻辑自旋（Spin）优化的应用场景实际开发中的使用建议。
GO 互斥锁实现原理剖析
weixin_34208283的博客
11-14 921
为什么80%的码农都做不了架构师？>>> ...
深入理解 go Mutex
m88997766的博客
03-31 474
这里引用一下维基百科的定义：互斥锁（，缩写Mutex）是一种用于多线程编程中，防止两个线程同时对同一公共资源 （比如全局变量）进行读写的机制。该目的通过将代码切片成一个一个的临界区域（）达成。临街区域指的是一块对公共资源进行访问的代码，并非一种机制或是算法。互斥，顾名思义，也就是只有一个线程能持有锁。当然，在 go 中，是只有一个协程能持有锁。var sum int // 和var mu sync.Mutex // 互斥锁// add 将 sum 加 1。
go的Mutex实现原理及演进
z3551906947的博客
07-19 1547
深入理解Mutex：通过学习 Mutex 的实现，我更深入地理解了并发编程中的同步机制和挑战。性能与公平性的权衡：理解了在设计并发系统时，性能和公平性之间的权衡是不可避免的。代码实践的重要性：理论知识需要通过实践来巩固，实际编写和测试并发代码是提高理解的关键。通过这些笔记，我希望能够更好地理解和应用 Go 语言中的并发原语，编写出更高效、更可靠的并发程序。同时，这些知识也为我提供了一个思考并发编程问题的框架，帮助我在面对并发挑战时做出更明智的设计决策。
go mutex原理
jinchenga的博客
07-01 97
自旋对应于CPU的”PAUSE”指令，CPU对该指令什么都不做，相当于CPU空转，对程序而言相当于sleep了一小段时间，时间非常短，当前实现是30个时钟周期。自旋过程中会持续探测Locked是否变为0，连续两次探测间隔就是执行这些PAUSE指令，它不同于sleep，不需要将协程转为睡眠状态。
Golang底层原理剖析之互斥锁sync.Mutex
清风
11-14 2978
互斥锁sync.MutexMutex概括Mutex.state状态标识Mutex源码剖析 Mutex概括 Mutex(Mutual exclusion),Go中Mutex的数据结构是这样的，因为足够简单，所以不需要额外的初始化，零值就是一个有效的互斥锁，处于Unlocked状态。state存储的是互斥锁的状态，加锁和解锁，都是通过atomic包提供的函数原子性，操作该字段。sema用作一个信号量，主要用于等待队列。 Mutex有两种模式，在正常模式下，一个尝试加锁的goroutine会先自旋四次，自旋锁
Golang中Sync包Mutex的原理解析
ZwqDatabase的博客
09-23 159
互斥锁的原理很简单：在任意时刻，只允许一个goroutine获取锁，并执行关键代码段。当一个goroutine尝试获取锁时，如果锁已经被其他goroutine持有，则当前goroutine会被阻塞，直到锁被释放。需要注意的是，在使用互斥锁时要遵循一些最佳实践，以避免潜在的问题。此外，应该尽量缩小锁的粒度，只在必要的临界区域内持有锁，避免锁的粗粒度使用导致性能下降。互斥锁（Mutex）是Golang中Sync包提供的一种同步原语，用于控制多个goroutine之间的访问共享资源的顺序。
Go语言互斥锁(Mutex)原理详解与实现
Go语言中的Mutex（互斥锁）是实现并发控制和同步的关键数据结构，它确保在任何时候只有一个goroutine（协程）能访问共享资源。本文档基于Go 1.14的源码分析，讲解了Mutex的基本原理，涵盖了加锁、解锁过程，以及其...
Golang中的可重入锁实现：基于Mutex的扩展
最新发布
Golang编程笔记的博客
04-17 791
本文旨在深入探讨Golang中可重入锁(Reentrant Lock)的实现方式，特别是如何基于标准库中的sync.Mutex进行扩展。我们将覆盖从基本概念到高级实现的全部内容，包括原理分析、代码实现、性能考量以及实际应用场景。文章首先介绍可重入锁的基本概念，然后分析Golang标准库的局限性，接着详细讲解基于Mutex的实现方案，最后探讨性能优化和实际应用。可重入锁(Reentrant Lock): 允许同一个线程多次获取同一把锁的同步机制Mutex: Golang标准库中的互斥锁实现。
Go 中的 Mutex 设计原理详解（三）
AFreeCoder的博客
01-18 260
Mutex系列是根据我对晁岳攀老师的《Go 并发编程实战课》的吸收和理解整理而成，如有偏差，欢迎指正~ Mutex 演变回顾 在前面两篇文章中，分别介绍了初版 Mutex 和 第二版 Mutex (给新人机会) 。 初版 Mutex 的核心思想用先来后到的方式解决锁的竞争问题。具体表现是用一个标志 key 来记录锁是否被占有，以及处于等待中的协程有多少个。等占有锁的协程完成任务后，按等待顺序唤醒下一个协程。表面上看，这样处理很公平，但是公平不能当饭吃，尤其是在高并发的场景下性能会比较低。性能较低的原因可.
万字图解| 深入揭秘Golang锁结构：Mutex（下）
云舒编程的博客
02-01 959
从golang mutex演进历史一步一步深入浅出的研究mutex的代码设计。最后实现手写一个属于自己的mutex
Golang Mutex 原理解析
m0_73849256的博客
09-23 581
自旋对应于 CPU 的PAUSE指令，CPU 对该指令什么都不做，相当于空转。对程序而言相当于sleep了很小一段时间，大概 30个时钟周期。连续两次探测Locked位的间隔就是在执行这些PAUSE指令，它不同于sleep，不需要将协程转为睡眠态。
Go互斥锁实现原理
07-19 1226
Go语言中的锁简单易用，本文整理一下锁的实现原理。Golang中锁有两种，互斥锁Mutex和读写互斥锁RWMutex，互斥锁也叫读锁，读写锁也叫读锁
go 使用 - sync.Metux
qq_40484416的博客
12-27 5291
简述使用metux使用的方法， 使用的注意点， 已经使用情况。
详解go中的混合锁 - mutex
热门推荐
李晨毅的博客
11-07 2万+
0 前言 我们知道，多线程下为了确保数据不会出错，必须加锁后才能访问共享资源。常见的锁包括互斥锁、自旋锁、读写锁等等，往往需要通过系统内核来实现。 然而协程的互斥锁实现原理完全不同，它并不与内核打交道，虽然不能跨线程工作，但却因为减少了用户态与内核态转换时所需的上下文切换环节，效率很高，是一个非常不错的选择。 本文以golang为例，用flowchart作图结合代码的形式，讲解在golang中是如何使用用户态的代码将锁重新实现的。   1 前提知识点 1.1 互斥锁与自旋锁 我们常见的各种锁是有.
深入理解 Golang 互斥锁：原理、应用与实践
m0_57836225的博客
01-04 1137
Golang 互斥锁通过巧妙的设计，在保证数据一致性的同时，兼顾了性能和公平性。理解其基本原理、适用场景、模式切换以及源码实现，有助于我们在并发编程中正确且高效地使用互斥锁。在实际应用中，我们应根据具体需求和场景选择合适的并发控制方式，并遵循使用原则，以避免因不当使用锁而导致的性能问题或死锁等并发陷阱。希望本文能够为大家在探索 Golang 并发编程的道路上提供有益的参考和指导。
万字图解| 深入揭秘Golang锁结构：Mutex（上）
云舒编程的博客
02-01 1082
从golang mutex演进历史一步一步深入浅出的研究mutex的代码设计。最后实现手写一个属于自己的mutex
golang Mutex剖析
qq_49723651的博客
12-12 971
golang Mutex剖析 文章目录golang Mutex剖析Mutex内存模型Mutex的两种模式正常模式饥饿模式Lock和Unlockslow path的主要逻辑加锁的slow path解锁的slow path Mutex内存模型 在go语言中，Mutex的结构是这样的： type Mutex struct { state int32 sema uint32 } 因为简单所以不需要额外的初始化。此结构的零值就是一个有效的互斥锁，处于Unlock的状态。 state储存的是互斥锁的状
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值