Go互斥锁（Mutex）

最新推荐文章于 2024-07-18 20:36:39 发布
最新推荐文章于 2024-07-18 20:36:39 发布
阅读量3.5k 收藏 10
点赞数 3
分类专栏： Golang 文章标签： golang 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53267860/article/details/123647030
版权

目录

Mutex

Go 语言的 sync.Mutex 由两个字段 state 和 sema 组成。其中 state 表示当前互斥锁的状态，而 sema 是用于控制锁状态的信号量。

type Mutex struct {
	state int32
	sema  uint32
}

上述两个加起来只占 8 字节空间的结构体表示了 Go 语言中的互斥锁。

状态

互斥锁的状态比较复杂，如下图所示，最低三位分别表示 mutexLocked、mutexWoken 和 mutexStarving，剩下的位置用来表示当前有多少个 Goroutine 在等待互斥锁的释放：

golang-mutex-state

互斥锁的状态

在默认情况下，互斥锁的所有状态位都是 0，int32 中的不同位分别表示了不同的状态：

  • mutexLocked — 表示互斥锁的锁定状态；
  • mutexWoken — 表示从正常模式被从唤醒；
  • mutexStarving — 当前的互斥锁进入饥饿状态；
  • waitersCount — 当前互斥锁上等待的 Goroutine 个数；
正常模式和饥饿模式

sync.Mutex 有两种模式 — 正常模式和饥饿模式。我们需要在这里先了解正常模式和饥饿模式都是什么以及它们有什么样的关系。

在正常模式下，锁的等待者会按照先进先出的顺序获取锁。但是刚被唤起的 Goroutine 与新创建的 Goroutine 竞争时，大概率会获取不到锁，为了减少这种情况的出现，一旦 Goroutine 超过 1ms 没有获取到锁，它就会将当前互斥锁切换饥饿模式，防止部分 Goroutine 被『饿死』。

golang-mutex-mode

互斥锁的正常模式与饥饿模式

饥饿模式是在 Go 语言在 1.9 中通过提交 sync: make Mutex more fair 引入的优化1，引入的目的是保证互斥锁的公平性。

在饥饿模式中，互斥锁会直接交给等待队列最前面的 Goroutine。新的 Goroutine 在该状态下不能获取锁、也不会进入自旋状态，它们只会在队列的末尾等待。如果一个 Goroutine 获得了互斥锁并且它在队列的末尾或者它等待的时间少于 1ms，那么当前的互斥锁就会切换回正常模式。

与饥饿模式相比，正常模式下的互斥锁能够提供更好地性能，饥饿模式的能避免 Goroutine 由于陷入等待无法获取锁而造成的高尾延时。

加锁和解锁

我们在这一节中将分别介绍互斥锁的加锁和解锁过程，它们分别使用 sync.Mutex.Lock 和 sync.Mutex.Unlock 方法。

互斥锁的加锁是靠 sync.Mutex.Lock 完成的，最新的 Go 语言源代码中已经将 sync.Mutex.Lock 方法进行了简化，方法的主干只保留最常见、简单的情况 — 当锁的状态是 0 时，将 mutexLocked 位置成 1：

func (m *Mutex) Lock() {
	if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
		return
	}
	m.lockSlow()
}

如果互斥锁的状态不是 0 时就会调用 sync.Mutex.lockSlow 尝试通过自旋（Spinnig）等方式等待锁的释放，该方法的主体是一个非常大 for 循环，这里将它分成几个部分介绍获取锁的过程：

  1. 判断当前 Goroutine 能否进入自旋；
  2. 通过自旋等待互斥锁的释放；
  3. 计算互斥锁的最新状态；
  4. 更新互斥锁的状态并获取锁；

我们先来介绍互斥锁是如何判断当前 Goroutine 能否进入自旋等互斥锁的释放：

func (m *Mutex) lockSlow() {
	var waitStartTime int64
	starving := false
	awoke := false
	iter := 0
	old := m.state
	for {
		if old&(mutexLocked|mutexStarving) == mutexLocked && runtime_canSpin(iter) {
			if !awoke && old&mutexWoken == 0 && old>>mutexWaiterShift != 0 &&
				atomic.CompareAndSwapInt32(&m.state, old, old|mutexWoken) {
				awoke = true
			}
			runtime_doSpin()
			iter++
			old = m.state
			continue
		}

自旋是一种多线程同步机制，当前的进程在进入自旋的过程中会一直保持 CPU 的占用，持续检查某个条件是否为真。在多核的 CPU 上，自旋可以避免 Goroutine 的切换，使用恰当会对性能带来很大的增益，但是使用的不恰当就会拖慢整个程序，所以 Goroutine 进入自旋的条件非常苛刻：

  1. 互斥锁只有在普通模式才能进入自旋；

  2. runtime.sync_runtime_canSpin

    需要返回true：

    1. 运行在多 CPU 的机器上；
    2. 当前 Goroutine 为了获取该锁进入自旋的次数小于四次；
    3. 当前机器上至少存在一个正在运行的处理器 P 并且处理的运行队列为空；

一旦当前 Goroutine 能够进入自旋就会调用runtime.sync_runtime_doSpin 和 runtime.procyield 并执行 30 次的 PAUSE 指令，该指令只会占用 CPU 并消耗 CPU 时间：

func sync_runtime_doSpin() {
	procyield(active_spin_cnt)
}

TEXT runtime·procyield(SB),NOSPLIT,$0-0
	MOVL	cycles+0(FP), AX
again:
	PAUSE
	SUBL	$1, AX
	JNZ	again
	RET

处理了自旋相关的特殊逻辑之后，互斥锁会根据上下文计算当前互斥锁最新的状态。几个不同的条件分别会更新 state 字段中存储的不同信息 — mutexLocked、mutexStarving、mutexWoken 和 mutexWaiterShift：

	new := old
		if old&mutexStarving == 0 {
			new |= mutexLocked
		}
		if old&(mutexLocked|mutexStarving) != 0 {
			new += 1 << mutexWaiterShift
		}
		if starving && old&mutexLocked != 0 {
			new |= mutexStarving
		}
		if awoke {
			new &^= mutexWoken
		}

计算了新的互斥锁状态之后，会使用 CAS 函数 sync/atomic.CompareAndSwapInt32 更新状态：

if atomic.CompareAndSwapInt32(&m.state, old, new) {
			if old&(mutexLocked|mutexStarving) == 0 {
				break // 通过 CAS 函数获取了锁
			}
			...
			runtime_SemacquireMutex(&m.sema, queueLifo, 1)
			starving = starving || runtime_nanotime()-waitStartTime > starvationThresholdNs
			old = m.state
			if old&mutexStarving != 0 {
				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
		}
	}
}

如果没有通过 CAS 获得锁，会调用 runtime.sync_runtime_SemacquireMutex 通过信号量保证资源不会被两个 Goroutine 获取。runtime.sync_runtime_SemacquireMutex 会在方法中不断尝试获取锁并陷入休眠等待信号量的释放，一旦当前 Goroutine 可以获取信号量，它就会立刻返回，sync.Mutex.Lock 的剩余代码也会继续执行。

  • 在正常模式下，这段代码会设置唤醒和饥饿标记、重置迭代次数并重新执行获取锁的循环；
  • 在饥饿模式下，当前 Goroutine 会获得互斥锁，如果等待队列中只存在当前 Goroutine，互斥锁还会从饥饿模式中退出；

互斥锁的解锁过程 sync.Mutex.Unlock 与加锁过程相比就很简单，该过程会先使用 sync/atomic.AddInt32 函数快速解锁，这时会发生下面的两种情况：

  • 如果该函数返回的新状态等于 0，当前 Goroutine 就成功解锁了互斥锁；
  • 如果该函数返回的新状态不等于 0，这段代码会调用 sync.Mutex.unlockSlow 开始慢速解锁：
func (m *Mutex) Unlock() {
	new := atomic.AddInt32(&m.state, -mutexLocked)
	if new != 0 {
		m.unlockSlow(new)
	}
}

sync.Mutex.unlockSlow 会先校验锁状态的合法性 — 如果当前互斥锁已经被解锁过了会直接抛出异常 “sync: unlock of unlocked mutex” 中止当前程序。

在正常情况下会根据当前互斥锁的状态，分别处理正常模式和饥饿模式下的互斥锁：

func (m *Mutex) unlockSlow(new int32) {
	if (new+mutexLocked)&mutexLocked == 0 {
		throw("sync: unlock of unlocked mutex")
	}
	if new&mutexStarving == 0 { // 正常模式
		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, 1)
				return
			}
			old = m.state
		}
	} else { // 饥饿模式
		runtime_Semrelease(&m.sema, true, 1)
	}
}
  • 在正常模式下，上述代码会使用如下所示的处理过程：
    • 如果互斥锁不存在等待者或者互斥锁的 mutexLocked、mutexStarving、mutexWoken 状态不都为 0，那么当前方法可以直接返回，不需要唤醒其他等待者；
    • 如果互斥锁存在等待者，会通过 sync.runtime_Semrelease 唤醒等待者并移交锁的所有权；
  • 在饥饿模式下，上述代码会直接调用 sync.runtime_Semrelease 将当前锁交给下一个正在尝试获取锁的等待者，等待者被唤醒后会得到锁，在这时互斥锁还不会退出饥饿状态；
小结

互斥锁的加锁过程比较复杂，它涉及自旋、信号量以及调度等概念：

  • 如果互斥锁处于初始化状态，会通过置位 mutexLocked 加锁；
  • 如果互斥锁处于 mutexLocked 状态并且在普通模式下工作，会进入自旋，执行 30 次 PAUSE 指令消耗 CPU 时间等待锁的释放；
  • 如果当前 Goroutine 等待锁的时间超过了 1ms，互斥锁就会切换到饥饿模式；
  • 互斥锁在正常情况下会通过 runtime.sync_runtime_SemacquireMutex 将尝试获取锁的 Goroutine 切换至休眠状态，等待锁的持有者唤醒；
  • 如果当前 Goroutine 是互斥锁上的最后一个等待的协程或者等待的时间小于 1ms，那么它会将互斥锁切换回正常模式；

互斥锁的解锁过程与之相比就比较简单，其代码行数不多、逻辑清晰，也比较容易理解：

  • 当互斥锁已经被解锁时，调用 sync.Mutex.Unlock 会直接抛出异常；
  • 当互斥锁处于饥饿模式时，将锁的所有权交给队列中的下一个等待者，等待者会负责设置 mutexLocked 标志位；
  • 当互斥锁处于普通模式时，如果没有 Goroutine 等待锁的释放或者已经有被唤醒的 Goroutine 获得了锁，会直接返回；在其他情况下会通过 sync.runtime_Semrelease 唤醒对应的 Goroutine；
~庞贝
关注
专栏目录
GO语言基础进阶教程：sync包——互斥锁
qfliweimin的博客
07-08 361
官网文档对sync包的介绍： Package sync provides basic synchronization primitives such as mutual exclusion locks. Other than the Once and WaitGroup types, most are intended for use by low-level library routines. Higher-level synchronization is better done via channe
Go 语言中的互斥锁 Mutex
禅与代码的艺术
07-16 1140
Go 语言中的互斥锁 Mutex
GO语言互斥锁
Xiang_lhh的博客
09-25 3538
1：使用互斥锁，将公共资源锁住，只能一个goroutine进行使用，使用完成之后，进行解锁，解锁之后，才能可以让下一个goroutine进行使用 package main import ( "fmt" "sync" "time" ) func main() { var lock sync.Mutex var i int = 1 go func() { lock.Lock() fmt.Println("func2初始状态", i) i++ defer lock.Unlock()
【Go 互斥锁与读写锁深入浅出】
最新发布
写写代码做做饭
07-18 945
在Web后端业务或者一些需要高IO的场景中，一些共享资源往往会被系统快速的修改。比如在电商的多线程的场景下，对一个商品数量的修改，往往是由多个用户同时修改。这些用户可以看作不同的线程，在多核CPU下出现并行修改，在单核CPU下出现并发修改。在Go中最简单的例子即是一个公共资源的数，在多个协程中进行累加。通过waitgroup原子数可以实现协程在主线程中等待退出，具体代码实现如下import ("fmt""sync"count := 0// 协程数量n := 10wg.Add(n)
go 互斥锁
ocean_fa的博客
06-22 201
go互斥锁 Mutex
Go并发编程之美-互斥锁
技术原始积累
02-12 123
一、前言go语言类似Java JUC包也提供了一些列用于多线程之间进行同步的措施，比如低级的同步措施有 锁、CAS、原子变量操作类。相比Java来说go提供了独特的基于通...
Go Mutex（互斥锁）
tongbowen_123的博客
09-14 326
如果一个goroutine尝试获得一个已经被另一个goroutine持有的mutex，它将被阻塞并且等待mutex被释放。mutex或者是mutual exclusion是一种机制，允许我们防止并发进入一个数据关键区域，在它已经被一个执行的进程执行。如果引进了多线程时，在Go的情况是多个goroutines，将会在代码中看到问题。假如你在写一个Go程序，有超过一个线程或者goroutine并发执行。假设有一个例子，有一个银行账户系统，存款和取款都从这个账户中。在一个线程中，同步程序，将会是难以置信的简单。
Go语言 互斥锁
qq_19018277的博客
04-02 264
说说 Go语言 的互斥锁~
Go 源码之互斥锁 Mutex
五岁小孩的博客
04-01 1031
Go 源码之互斥锁 Mutex
go的互斥锁Mutex以及条件变量Condition
weixin_44718747的博客
12-21 703
锁 go中的锁分为两类： 互斥锁Sync.Mutex：特别的如果要实现对象锁的话，可以在定义该对象的结构体时封装一个互斥锁成员,比如 type struct Resource{ resource int lock sync.mutex } 读写锁 sync.RWMutex：读-写、写-读 以及写-写操作互斥，但读-读操作可以并发执行，操作如下： func (*RWMutex) Lock() // 写锁 func (*RWMutex) Unlock() // 解写锁
深入理解 golang 的互斥锁
Go中国
11-30 1297
How to implement Golang Mutex golang 是如何实现互斥锁的在开始之前，我们需要知道锁实现的几种方式。# 信号量操作系统中有 P 和 V 操作。P 操作是将信号量值减去 1，V 操作是将信号量值增加 1.因此信号量的操作模式为：初始化，给它一个非负整数值。在程序试图进入临界区之前需要先运行 P 操作，然后会有两种情况。当信号量 S 减少到负值时，该过程将被阻止并且...
Golang中互斥锁和读写互斥锁
周小末天天开心的博客
05-24 2321
在Go语言中，互斥锁（Mutex）是一种基本的同步原语，用于实现对共享资源的互斥访问。互斥锁通过在代码中标记临界区来控制对共享资源的访问，从而保证同一时间只有一个 goroutine 可以访问共享资源，避免了并发访问时的数据竞争和不一致性问题。互斥锁的主要方法包括两个，分别是 Lock 和 Unlock。Lock 方法用于锁定共享资源，防止其他 goroutine 访问；Unlock 方法则用于解锁共享资源，允许其他 goroutine 访问。
Go 互斥锁
咳咳，请多指教
03-13 127
package main import ( "fmt" "sync" ) // sync.Mutex var ( x int64 wg sync.WaitGroup // 等待组 m sync.Mutex // 互斥锁 ) // add 对全局变量x执行5000次加1操作 func add() { for i := 0; i < 5000; i++ { m.Lock() // 修改x前加锁 x = x + 1 m.Unlock() // 改完解锁 } wg.Do
Go并发编程-互斥锁
技术原始积累
02-04 863
一、前言go语言为了保证多goroutine对同一个共享资源进行并发读写，提供了一些列用于多线程之间进行同步的措施，比如低级的同步措施有 锁、CAS、原子变量操作类，本节我们先来看看go...
golang基础-互斥锁、读写锁
热门推荐
全干工程师
10-26 2万+
互斥锁其中Mutex为互斥锁，Lock()加锁，Unlock()解锁，使用Lock()加锁后，便不能再次对其进行加锁，直到利用Unlock()解锁对其解锁后，才能再次加锁．适用于读写不确定场景，即读写次数没有明显的区别，并且只允许只有一个读或者写的场景，所以该锁叶叫做全局锁。 func (m *Mutex) Unlock()用于解锁m，如果在使用Unlock()前未加锁，就会引起一个运行错误．已经
go互斥锁（syn包）
要好好学习
03-23 284
并发编程还没整理，先把互斥锁啥的发一下吧（有参考李文周的博客）
go语言 互斥锁 读写锁
Waller_的博客
07-28 662
互斥锁 每个资源都对应于一个可称为"互斥锁"的标记，这个标记用来保证在任意时刻，只能有一个协程（线程）访问该资源。其它的协程只能等待。 互斥锁是传统并发编程对共享资源进行访问控制的主要手段，它由标准库sync中的Mutex结构体类型表示。sync.Mutex类型只有两个公开的指针方法，Lock和Unlock。Lock锁定当前的共享资源，Unlock进行解锁。 在使用互斥锁时，一定要注意：对资源操作完成后，一定要解锁，否则会出现流程执行异常，死锁等问题。通常借助defer。锁定后，立即使用defer..
Go语言，互斥锁使用
weixin_33857230的博客
06-30 89
package main import ( "fmt" "runtime" "sync" ) var ( counter int wg sync.WaitGroup mutex sync.Mutex ) func main() { wg.Add(2) fmt.Println("Create Goroutines") go incC...
【Go学习】GO语言并发编程之互斥锁
谢健的专栏
06-12 739
【Go学习】GO语言并发编程之互斥锁 互斥锁是传统的并发程序对共享资源进行访问控制的主要手段。它由标准库代码包sync中的Mutex结构体类型代表。sync.Mutex类型（确切地说，是*sync.Mutex类型）只有两个公开方法——Lock和Unlock。顾名思义，前者被用于锁定当前的互斥量，而后者则被用来对当前的互斥量进行解锁。 类型sync.Mutex的零值表示了未被锁定的互斥量。也就是...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值