Go-知识并发控制mutex

Go-知识并发控制mutex

  • 1. 介绍
  • 2. 数据结构
    • 2.1 Mutex 结构体
    • 2.2 Mutex 方法
  • 3. 加锁解锁过程
    • 3.1 简单加锁
    • 3.2 加锁被阻塞
    • 3.3 简单解锁
    • 3.4 解锁并唤醒协程
  • 4. 自旋过程
    • 4.1 什么是自旋
    • 4.2 自旋条件
    • 4.3 自旋的优势
    • 4.4 自旋的问题
  • 5. Mutex 模式
    • 5.1 Normal 模式
    • 5.2 Starving 模式(饥饿模式)
  • 6. Woken 状态
  • 7. 重复解锁引发 panic
  • 8. 总结

gitio: https://a18792721831.github.io/

1. 介绍

互斥锁是并发程序中对共享资源进行访问控制的主要手段，Go 语言提供了非常简单易用的 Mutex。
Mutex 是结构体类型，对外暴露了 Lock 和 Unlock 两个方法，用于加锁和解锁。

2. 数据结构

2.1 Mutex 结构体

在源码包 src/sync/mutex.go中定义了互斥锁的数据结构：
在这里插入图片描述

Mutex.state 表示互斥锁的状态，比如是否被锁定等等
Mutex.sema 表示信号量，协程阻塞等待该信号量，解锁的写成释放信号量，从而唤醒等待信号量的协程

其中 Mutex.state 是 32 位的整型变量，内部实现时，把该变量分成四部分，用于记录 Mutex 的四种状态。
在这里插入图片描述

  • Locked: 表示该 Mutex 是否已被锁定，0表示没有锁定，1表示已被锁定.
  • Woken: 表示是否有协程已被唤醒，0表示没有协程唤醒，1表示已有协程唤醒，正在加锁过程中.
  • Starving: 表示该 Mutex 是否处于饥饿状态，0表示没有饥饿，1表示饥饿，说明有协程阻塞超过了1ms
  • Waiter: 表示阻塞等待锁的协程个数，协程解锁时根据此值来判断是否需要释放信号量。

协程之间的抢锁实际上是抢给 Locked 赋值的权利，能给 Locked 赋值 1，就说明抢锁成功。
抢不到就阻塞等待 Mutex.sema 信号量，一旦持有锁的协程解锁，等待的协程就会依次被唤醒。

2.2 Mutex 方法

Mutex 对外提供的方法主要是加锁和解锁：

  • Lock(): 加锁
  • Unlock(): 解锁
  • TryLock(): 非阻塞的方式尝试加锁(Go 1.18 引入)

3. 加锁解锁过程

3.1 简单加锁

假设当前只有一个协程在加锁，没有其他协程干扰：
在这里插入图片描述

加锁过程中会判断 Locked 的标志位是否为0，如果是0则把 Locked 位置为1，代表大锁成功。
如上图所示，加锁成功后，只有 Locked 位置为1，其他位置都没变。

func (m *Mutex) Lock() {
	// 快速尝试，使用 cas 进行加锁，如果 state 等于 0 表示无锁
	if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
		return
	}
	// 否则就需要慢加锁了
	m.lockSlow()
}

func (m *Mutex) lockSlow() {
    // 等待开始时间
	var waitStartime int64
	// 是否饥饿
	starving := false
	// 是否有协程被唤醒
	awoke := false
	iter := 0
	// 获取 state 值
	old := m.state
	// 死循环
	for {
		// old & mutexLocked 表示取出 Locked 位
		// old & mutexStarving 表示取出 Starving 位
		// old & (mutexLocked | mutexStarving) 表示取出 Locked 或 starving 位
		// 所以 old & (mutexLocked|mutexStarving) == mutexLocked 表示 Locked 或 Starving 等于 1。
		// 要么有锁，要么饥饿
		// 并且当前 goroutine 可以进行自旋
		if old&(mutexLocked|mutexStarving) == mutexLocked && runtime_canSpin(iter) {
			// 没有饥饿 而且 没有协程被唤醒 并且 Waiter 等待的协程不为空
			// 尝试使用 CAS 设置 Worken 值，表示有 goroutine 被唤醒了，在自旋等待锁
			if !awoke && old&mutexWoken == 0 && old>>mutexWaiterShift != 0 &&
				atomic.CompareAndSwapInt32(&m.state, old, old|mutexWoken) {
				// 是否有协程被唤醒标志置为 true 
				awoke = true
			}
			// 自旋 ，我认为可以理解为 continue ..
			runtime_doSpin()
			// 自旋次数加1
			iter++
			// 重新获取最新的 state 值
			old = m.state
			// 自旋
			continue
		}
		// 重新获取 state
		new := old
		// 没有饥饿
		if old&mutexStarving == 0 {
		    // 新值设置为加锁了
			new |= mutexLocked
		}
		// 如果存在饥饿或者有锁
		if old&(mutexLocked|mutexStarving) != 0 {
		    // Waiter 数量增加 1 
		    // 1<<mutexWaiterShift 表示将1左移3位，1000
		    // new += 1000 表示将 Waiter + 1
			new += 1 << mutexWaiterShift
		}
		// 饥饿 并且 有锁
		if starving && old&mutexLocked != 0 {
		    // new 设置 Starving 位为1
			new |= mutexStarving
		}
		// 如果有唤醒的协程
		if awoke {
			// 如果新值的 Woken 为 0 
			if new&mutexWoken == 0 {
			    // 当前协程就是唤醒的协程
				throw("sync: inconsistent mutex state")
			}
			// 异或运算 将 Woken 位清除
			new &^= mutexWoken
		}
		// 设置有锁，设置没有唤醒的协程，保留饥饿，Waiter + 1
		// 放弃自旋，放弃唤醒，进入阻塞并等待
		if atomic.CompareAndSwapInt32(&m.state, old, new) {
		    // 如果既没有锁，而且也没有饥饿，表示拿到了锁
			if old&(mutexLocked|mutexStarving) == 0 {
			    // 自旋获得了锁
				break // 用CAS锁定了互斥对象
			}
			// 等待时间不为0，表示之前就在等待中
			queueLifo := waitStartTime != 0
			if waitStartTime == 0 {
			    // 如果等待时间为0，表示第一次等待
				waitStartTime = runtime_nanotime()
			}
			// 根据等待时间，将当前 goroutine 放到队列头或者尾
			runtime_SemacquireMutex(&m.sema, queueLifo, 1)
			// 设置是否饥饿
			// 如果原来就饥饿，那么依然饥饿
			// 或者等待时间超过限制，那么也是饥饿
			starving = starving || runtime_nanotime()-waitStartTime > starvationThresholdNs
			// 重新获取 state 
			old = m.state
			// 如果存在饥饿
			if old&mutexStarving != 0 {
			    // 有锁 或 有唤醒的协程 或者
			    // 没有等待的协程
				if old&(mutexLocked|mutexWoken) != 0 || old>>mutexWaiterShift == 0 {
				    // 不能即处于饥饿，有存在唤醒，还没有锁
				    // 不能没有等待的协程，又处于饥饿状态
					throw("sync: inconsistent mutex state")
				}
				// 表示 1 减去 1000 = -7 
				delta := int32(mutexLocked - 1<<mutexWaiterShift)
				// 如果不是饥饿模式 或者 Waiter 等于 1
				if !starving || old>>mutexWaiterShift == 1 {
					// -7 减去 -4 ,移除饥饿模式
					delta -= mutexStarving
				}
				// 更新 state
				// 防止自旋死锁
				atomic.AddInt32(&m.state, delta)
				break
			}
			awoke = true
			iter = 0
		} else {
			old = m.state
		}
	}
}

3.2 加锁被阻塞

假设加锁时，锁已经被其他协程占用了：
在这里插入图片描述

当协程B对一个已被占用的锁再次加锁时，Waiter 计数器增加1，此时协程B被阻塞，直到 Locked 值变为0后才会被唤醒。

3.3 简单解锁

假设解锁时，没有其他协程阻塞：
在这里插入图片描述

由于没有其他协程阻塞等待加锁，所以此时解锁时只需要把 Locked 位置为0即可，不需要释放信号量。

func (m *Mutex) Unlock() {
	// 使用 CAS 快速解锁
	new := atomic.AddInt32(&m.state, -mutexLocked)
	// 如果 CAS 解锁失败，那么尝试慢解锁
	if new != 0 {
		m.unlockSlow(new)
	}
}

func (m *Mutex) unlockSlow(new int32) {
    // 如果 无锁 new 最低位 1，因为在 Unlock 中已经减去 1 了 ，1+1 = 10 ， 0 & 1 = 0 ， 0 == 0 
    // 如果 有锁 new 最低位 0，0+1 = 1, 1 & 1 = 1, 1 == 0
    // 所以，无锁异常，有锁继续 
	if (new+mutexLocked)&mutexLocked == 0 {
		throw("sync: unlock of unlocked mutex")
	}
	// 如果没有饥饿
	if new&mutexStarving == 0 {
	    // 临时赋值
		old := new
		for {
		    // Waiter 等于 0 ，没有等待的协程 或
		    // 处于 饥饿，有锁，有唤醒 ，结束
			if old>>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken|mutexStarving) != 0 {
				return
			}
			// Waiter 减 1，并且 保留唤醒状态
			new = (old - 1<<mutexWaiterShift) | mutexWoken
			// 尝试使用 CAS 将 Waiter 减 1 ，同时设置无锁
			if atomic.CompareAndSwapInt32(&m.state, old, new) {
			    // 释放 1 个信号量
				runtime_Semrelease(&m.sema, false, 1)
				return
			}
			old = m.state
		}
	} else {
		// 如果处理饥饿模式，直接唤醒协程，释放信号量
		runtime_Semrelease(&m.sema, true, 1)
	}
}

3.4 解锁并唤醒协程

假设解锁时，有一个或多个协程阻塞：
在这里插入图片描述

协程A解锁过程分为两个步骤，一是把 Locked 位置为0，二是看到 Waiter > 0 ，释放1个信号量，唤醒一个阻塞的协程，被唤醒的协程 B 把 Locked 位置为1，于是协程B获得锁。

4. 自旋过程

加锁时，如果当前 Locked 位为1，则说明该锁当前由其他协程持有，尝试加锁的协程并不是马上转入阻塞，而是会持续的探测 Locked 位是否变为 0 ，这个过程称为自旋过程。
自旋时间很短，如果在自旋过程中发现锁已经被释放，那么协程可以立即获取锁。此时即便有协程被唤醒也无法获取锁，只能再次阻塞。
自旋的好处是，当加锁失败时，不必立即转入阻塞，有一定机会获取到锁，这样可以避免协程的切换。

4.1 什么是自旋

自旋对应于CPU的PAUSE指令，CPU对该指令什么都不做，相当于CPU空转，对程序而言相当于 sleep 了一小段时间，时间非常短，当前实现是 30个时钟周期。
自旋过程中会持续探测 Locked 是否变为0 ，连续两次探测奸恶就是在执行这些 PAUSE 指令，不同于sleep，不需要将协程转为睡眠状态。

4.2 自旋条件

加锁时，程序会自动判断是否可以自旋，无限制的自旋会给CPU带来巨大压力，所以判断是否可以自旋就很重要了。
自旋必须满足一下所有条件：

  • 自旋次数要足够小，通常为 4 ，即自旋最多4次
  • CPU核数大于1，否则自旋没有意义，因为此时不可能有其他协程释放锁
  • 协程调度机制中的 Process 数量要大于1，比如使用 GOMAXPROCESS() 将处理器设置为1就不能启动自旋
  • 协程调度机制中的可运行队列必须为空，否则会延迟协程调度。

简单来说就是 不忙 的时候才会启动自旋

4.3 自旋的优势

自旋的优势是更充分地利用CPU，尽量避免协程切换。因为当前申请加锁的协程拥有CPU，如果经过短时间的自旋可以获得锁，则蒋倩协程可以继续运行，不必进入阻塞状态。

4.4 自旋的问题

如果自旋过程中获得锁，那么之前被阻塞的协程将无法获得锁，如果加锁的协程特别多，每次都通过自旋获得锁，那么之前被阻塞的协程将很难获得锁，从而进入 Starving 状态。
为了避免协程长时间无法获取锁，自 1.8 版本依赖增加了一个状态， Starving 。在这个状态下不会自旋，一旦有协程释放锁，那么一定会唤醒一个协程并成功加锁。

5. Mutex 模式

每个 Mutex 都有两个模式，Normal 和 Starving 。

5.1 Normal 模式

默认情况下，Mutex 的模式是 Normal。
在Normal模式下，如果协程加锁不成功不会立即转为阻塞排队，而是判断是否满足自旋的条件，如果满足则会启动自旋，尝试抢锁。

5.2 Starving 模式(饥饿模式)

自旋过程中能抢到锁，一定意味着同一时间有协程释放了锁。释放锁时，如果发现有阻塞等待的协程，那么还会释放一个信号量来唤醒一个等待协程，
被唤醒的协程得到CPU后开始运行，此时发现锁已经被抢占了，只能再次阻塞。阻塞钱会判断自上次阻塞到本次阻塞经过了多长时间，如果超过1ms，则会将Mutex 标记为 Starving 模式，然后阻塞。
在 Starving 模式下，不会启动自旋过程，即一旦有协程释放了锁，那么一定会唤醒协程，被唤醒的协程将乘公共获取锁，同时会把等待计数减1.

6. Woken 状态

Woken 状态用与加锁和解锁过程的通信。
比如同一个时刻，两个协程一个在加锁，另一个在解锁，加锁的协程可能在自旋过程中，此时把 Woken 标记为1，用于通知解锁协程不必释放信号量。
存在唤醒中的协程，不需要信号量唤醒。

7. 重复解锁引发 panic

如果 Mutex 处于无锁状态，执行 Unlock 会触发 panic。
Unlock 的逻辑分为两个过程： 将 Locked 置为 0 ；判断 Waiter 数量，Waiter > 0，释放一个信号量。
如果多次执行Unlock，那么可能每次都释放一个信号量，这样会唤醒多个协程，多个协程被唤醒后继续在 Lock 的逻辑中抢锁，就需要在 Lock 的逻辑中增加更多场景，
并且引发更多的协程切换。

8. 总结

在使用 Mutex 的时候，使用 defer 避免死锁。加锁后立即使用 defer 解锁，可以有效避免死锁。
加锁和解锁应该成对出现，最好是出现在同一个层次的代码块中，否则很容易引发因重复解锁导致的panic 。

(Java允许重复 release)

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/728470.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

React实现H5手势密码

React实现H5手势密码

监测应用进入前后台 在JavaScript中&#xff0c;监听H5页面是否在前台或后台运行&#xff0c;主要依赖于Page Visibility API。这个API在大多数现代浏览器中都是支持的&#xff0c;包括苹果的Safari和谷歌的Chrome&#xff08;也就基本覆盖了Android和iOS平台&#xff09;。下…
阅读更多...
RabbitMQ 学习笔记

RabbitMQ 学习笔记

RabbitMQ学习笔记 一些概念 Broker &#xff1a;RabbitMQ服务。 virtual host&#xff1a; 其实就是分组。 Connection&#xff1a;连接&#xff0c;生产者消费者与Broker之间的TCP连接。 Channel&#xff1a;网络信道&#xff0c;轻量级的Connection&#xff0c;使用Chann…
阅读更多...
【C++】一个极简但完整的C++程序

【C++】一个极简但完整的C++程序

一、一个极简但完整的C程序 我们编写程序是为了解决问题和任务的。 1、任务&#xff1a; 某个书店将每本售出的图书的书名和出版社&#xff0c;输入到一个文件中&#xff0c;这些信息以书售出的时间顺序输入&#xff0c;每两周店主会手工计算每本书的销售量、以及每个出版社的…
阅读更多...
任务调度框架革新：TASKCTL在Docker环境中的高级应用

任务调度框架革新：TASKCTL在Docker环境中的高级应用

Docker&#xff1a;轻量级容器化技术的魅力 Docker 作为一款开源的轻量级容器化技术&#xff0c;近年来在 IT 界掀起了一股热潮。它通过封装应用及其运行环境&#xff0c;使得开发者可以快速构建、部署和运行应用。Docker 的优势在于其轻量级、可移植性和可扩展性&#xff0c;它…
阅读更多...
http和https的区别在哪

http和https的区别在哪

HTTP&#xff08;超文本传输协议&#xff09;和HTTPS&#xff08;超文本传输安全协议&#xff09;之间存在几个关键区别主要涉及安全性、端口、成本、加密方式、搜索引擎优化&#xff08;SEO&#xff09;、身份验证等方面 1、安全性&#xff1a;HTTP&#xff08;超文本传输协议…
阅读更多...
Python | Leetcode Python题解之第171题Excel列表序号

Python | Leetcode Python题解之第171题Excel列表序号

题目&#xff1a; 题解&#xff1a; class Solution:def titleToNumber(self, columnTitle: str) -> int:number, multiple 0, 1for i in range(len(columnTitle) - 1, -1, -1):k ord(columnTitle[i]) - ord("A") 1number k * multiplemultiple * 26return n…
阅读更多...
CASS界址点顺序重排

CASS界址点顺序重排

1、绘制一个宗地&#xff0c;如下&#xff1a; 2、注记界址点号&#xff0c;如下 3、【地籍】--【调整宗地内界址点顺序】&#xff0c;如下&#xff1a; 重排完成后&#xff0c;点击工具栏的【重】按钮&#xff0c;即可刷新标注。
阅读更多...
Docker 拉取镜像失败处理 配置使用代理拉取

Docker 拉取镜像失败处理 配置使用代理拉取

解决方案 1、在 /etc/systemd/system/docker.service.d/http-proxy.conf 配置文件中添加代理信息 2、重启docker服务 具体操作如下&#xff1a; 创建 dockerd 相关的 systemd 目录&#xff0c;这个目录下的配置将覆盖 dockerd 的默认配置 代码语言&#xff1a;javascript 复…
阅读更多...
Golang | Leetcode Golang题解之第171题Excel列表序号

Golang | Leetcode Golang题解之第171题Excel列表序号

题目&#xff1a; 题解&#xff1a; func titleToNumber(columnTitle string) (number int) {for i, multiple : len(columnTitle)-1, 1; i > 0; i-- {k : columnTitle[i] - A 1number int(k) * multiplemultiple * 26}return }
阅读更多...
Linux——ansible关于“文件操作”的模块

Linux——ansible关于“文件操作”的模块

修改文件并将其复制到主机 一、确保受管主机上存在文件 使用 file 模块处理受管主机上的文件。其工作方式与 touch 命令类似&#xff0c;如果不存在则创建一个空文件&#xff0c;如果存在&#xff0c;则更新其修改时间。在本例中&#xff0c;除了处理文件之外&#xff0c;Ansi…
阅读更多...
2024广东省职业技能大赛云计算赛项实战——Redis主从架构

2024广东省职业技能大赛云计算赛项实战——Redis主从架构

Redis主从架构 前言 Redis是一个开源的内存数据结构存储系统&#xff0c;一般用于作为数据库、缓存和消息代理使用&#xff0c;而主从架构是许多分布式系统中常见的设计模式&#xff0c;用来提高系统的性能、可靠性和扩展性。 虚拟机使用的是自行创建的CentOS7&#xff0c;如…
阅读更多...
自定义平台后台登录地址前缀的教程

自定义平台后台登录地址前缀的教程

修改平台后台地址默认的 admin 前缀 修改后端 config/admin.php 配置文件,为自定义的后缀 修改 平台后台前端源码中 src/settings.js 文件,修改为和上面一样的配置 修改后重新打包前端代码,并且覆盖到后端的 public 目录下 重启 swoole 服务即可
阅读更多...
关于如何得到Mindspore lite所需要的.ms模型

关于如何得到Mindspore lite所需要的.ms模型

关于如何得到Mindspore lite所需要的.ms模型 一、.ckpt模型文件转.mindir模型二、.mindir模型转.ms模型三、其它3.1 代码3.2 数据 四、参考文档 一、.ckpt模型文件转.mindir模型 由于要得到ms模型&#xff0c;mindspore的所有模型里面&#xff0c;是必须要用mindir模型才可以进…
阅读更多...
计算机毕业设计Python深度学习房价预测 房价可视化 链家爬虫 房源爬虫 房源可视化 卷积神经网络 大数据毕业设计 机器学习 人工智能 AI

计算机毕业设计Python深度学习房价预测 房价可视化 链家爬虫 房源爬虫 房源可视化 卷积神经网络 大数据毕业设计 机器学习 人工智能 AI

基于python一/二手房数据爬虫分析预测系统可视化 商品房数据Flask框架&#xff08;附源码&#xff09; 项目介绍python语言、Flask框架、MySQL数据库、Echarts可视化 sklearn机器学习 多元线性回归预测模型、requests爬虫框架 链家一手房 一手房数据商品房数据、分析可视化预测…
阅读更多...
Unexpected tokens (use ‘；‘ to separate expressions on the same line)

Unexpected tokens (use ‘；‘ to separate expressions on the same line)

idear配置gradle时,出现这样的错误&#xff1a; 一、dependencies dependencies { testImplementation(platform("org.junit.jupiter:junit-jupiter-api:5.9.1")) testImplementation("org.junit.jupiter:junit-jupiter-engine:5.9.1") // https://mvnr…
阅读更多...
苹果电脑如何清理磁盘空间 苹果电脑如何清理系统数据

苹果电脑如何清理磁盘空间 苹果电脑如何清理系统数据

你是否遇到过电脑磁盘空间不足的情况呢&#xff1f;Mac电脑有着流畅的操作系统&#xff0c;但是随着日常使用&#xff0c;可能电脑里的垃圾文件越来越多&#xff0c;导致磁盘空间不足&#xff0c;随之会出现电脑卡顿、软件闪退等情况。及时清理磁盘空间可以有效避免电脑这些问题…
阅读更多...
腾讯云开端口

腾讯云开端口

轻量服务器 由于开发者计划&#xff0c;这些腾讯云 阿里云什么的小vps&#xff0c;是非常之便宜&#xff0c;甚至到了白送的地步&#xff08;小阿&#xff09;&#xff0c;但是作为一个web安全学习者必要的vps操作还是要会的 开启端口 腾讯云的轻量服务器是没有安全组的&…
阅读更多...
【总线】AXI4第二课时：深入AXI4总线的基础事务

【总线】AXI4第二课时：深入AXI4总线的基础事务

大家好,欢迎来到今天的总线学习时间!如果你对电子设计、特别是FPGA和SoC设计感兴趣&#xff0c;那你绝对不能错过我们今天的主角——AXI4总线。作为ARM公司AMBA总线家族中的佼佼者&#xff0c;AXI4以其高性能和高度可扩展性&#xff0c;成为了现代电子系统中不可或缺的通信桥梁…
阅读更多...
数据结构之“算法的时间复杂度和空间复杂度”

数据结构之“算法的时间复杂度和空间复杂度”

&#x1f339;个人主页&#x1f339;&#xff1a;喜欢草莓熊的bear &#x1f339;专栏&#x1f339;&#xff1a;数据结构 目录 前言 一、算法效率 1.1算法的复杂度概念 1.2复杂度的重要性 二、时间复杂度 2.1时间复杂度的概念 2.2大O的渐进表示法 2.3常见的时间复杂度…
阅读更多...
Spring Boot -- 图书管理系统（登录、展示+翻页、添加/修改图书）

Spring Boot -- 图书管理系统（登录、展示+翻页、添加/修改图书）

文章目录 一、应用分层二、数据库的设计三、登录功能四、展示列表&#xff08;使用虚构的数据&#xff09;五、翻页 展示功能六、添加图书七、修改图书 一、应用分层 为什么我们需要应用分层&#xff1a;当代码量很多时&#xff0c;将其全部放在一起查找起来就会很麻烦&#…
阅读更多...
最新文章

Copyright @ 2022~2023