go语言---锁

什么是锁呢？就是某个协程（线程）在访问某个资源时先锁住，防止其它协程的访问，等访问完毕解锁后其他协程再来加锁进行访问。这和我们生活中加锁使用公共资源相似，例如：公共卫生间。

死锁

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，
死锁： 不是锁的一种！！！是一种错误使用锁导致的现象。

1. 单go程自己死锁channel 应该在 至少 2 个以上的 go程中进行通信。否则死锁！！！2. go程间channel访问顺序导致死锁使用channel一端读（写）， 要保证另一端写（读）操作，同时有机会执行。否则死锁。3. 多go程，多channel 交叉死锁Ago程，掌握M的同时，尝试拿N； Bgo程，掌握N的同时尝试拿M。 4. 在go语言中，尽量不要将 互斥锁、读写锁 与 channel 混用。 ——  隐性死锁。

//单go程自己死锁ch := make(chan int) //channel
ch <- 789            //写 这里写入就会阻塞
num := <-ch          //读
fmt.Println(num)

//go程间channel访问顺序导致死锁ch := make(chan int)num := <-ch //顺序不对，阻塞了，那么go就不执行了fmt.Println(num)go func() {ch <- 789}()

//多go程，多channel 交叉死锁ch1 := make(chan int)
ch2 := make(chan int)go func() {				// 子for {select {case num := <-ch1:ch2 <- num}}}()for {select {case num := <- ch2:ch1 <- num}}

4. 在go语言中，尽量不要将 互斥锁、读写锁 与 channel 混用。 ——  隐性死锁。
package mainimport ("fmt""math/rand""sync""time"
)var rwMutex sync.RWMutex //锁只有一把，两个属性// 左写右读
// <-chan int 读
func readGo(in <-chan int, index int) {for {rwMutex.RLock() //以读模式加锁num := <-infmt.Printf("----%dth 读 go程，读出：%d\n", index, num)time.Sleep(time.Second)rwMutex.RUnlock() //以读模式写锁}
}// chan<- int 写
func writeGo(out chan<- int, index int) {for {//生成随机数num := rand.Intn(1000)rwMutex.Lock() //以写模式加锁out <- num     //写进去fmt.Printf("%dth 写go程，写入：%d\n", index, num)time.Sleep(time.Millisecond * 300) // 放大实验现象rwMutex.Unlock()                   //解锁}
}func main() {// 播种随机数种子rand.Seed(time.Now().UnixNano())ch := make(chan int)for i := 0; i < 5; i++ {go readGo(ch, i+1)}for i := 0; i < 5; i++ {go writeGo(ch, i+1)}for true {}
}

互斥锁

每个资源都对应于一个可称为 “互斥锁” 的标记，这个标记用来保证在任意时刻，只能有一个协程（线程）访问该资源。其它的协程只能等待。
互斥锁是传统并发编程对共享资源进行访问控制的主要手段，它由标准库sync中的Mutex结构体类型表示。sync.Mutex类型只有两个公开的指针方法，Lock和Unlock。Lock锁定当前的共享资源，Unlock进行解锁。
在使用互斥锁时，一定要注意：对资源操作完成后，一定要解锁，否则会出现流程执行异常，死锁等问题。通常借助defer。锁定后，立即使用defer语句保证互斥锁及时解锁。如下所示：
var mutex sync.Mutex // 定义互斥锁变量 mutex

func write(){
mutex.Lock( )
defer mutex.Unlock( )
}

互斥锁：（互斥量）

A 、B go程 共同访问共享数据。 由于cpu调度随机，需要对 共享数据访问顺序加以限定（同步）。

创建 mutex（互斥锁），访问共享数据之前，加锁，访问结束，解锁。 在Ago程加锁期间，B go程加锁会失败——阻塞。

直至 A go程 解说mutex，B 从阻塞处。恢复执行。

package mainimport ("fmt""time""sync"
)// 使用channel 完成同步
/*var ch = make(chan int)func printer(str string)  {for _, ch := range str {fmt.Printf("%c", ch)time.Sleep(time.Millisecond * 300)}
}func person1()  {				// 先printer("hello")ch <- 98
}func person2()  {				// 后<- chprinter("world")
}func main()  {go person1()go person2()for {;}
}
*/// 使用 “锁” 完成同步 —— 互斥锁
var mutex sync.Mutex		// 创建一个互斥量， 新建的互斥锁状态为 0. 未加锁。 锁只有一把。func printer(str string)  {mutex.Lock()			// 访问共享数据之前，加锁for _, ch := range str {fmt.Printf("%c", ch)time.Sleep(time.Millisecond * 300)}mutex.Unlock()			// 共享数据访问结束，解锁
}func person1()  {				// 先printer("hello")
}func person2()  {				// 后printer("world")
}func main()  {go person1()go person2()for {;}
}

读写锁

互斥锁的本质是当一个goroutine访问的时候，其他goroutine都不能访问。这样在资源同步，避免竞争的同时也降低了程序的并发性能。程序由原来的并行执行变成了串行执行。
其实，当我们对一个不会变化的数据只做“读”操作的话，是不存在资源竞争的问题的。因为数据是不变的，不管怎么读取，多少goroutine同时读取，都是可以的。
所以问题不是出在“读”上，主要是修改，也就是“写”。修改的数据要同步，这样其他goroutine才可以感知到。所以真正的互斥应该是读取和修改、修改和修改之间，读和读是没有互斥操作的必要的。
因此，衍生出另外一种锁，叫做读写锁。
读写锁可以让多个读操作并发，同时读取，但是对于写操作是完全互斥的。也就是说，当一个goroutine进行写操作的时候，其他goroutine既不能进行读操作，也不能进行写操作。
GO中的读写锁由结构体类型sync.RWMutex表示。此类型的方法集合中包含两对方法：
一组是对写操作的锁定和解锁，简称“写锁定”和“写解锁”：
func (*RWMutex)Lock()
func (*RWMutex)Unlock()
另一组表示对读操作的锁定和解锁，简称为“读锁定”与“读解锁”：
func (*RWMutex)RLock()
func (*RWMutex)RUlock()
读写锁：
读时共享，写时独占。写锁优先级比读锁高。

读写锁—数据同步

package mainimport ("fmt""math/rand""sync""time"
)var rwMutex sync.RWMutex //锁只有一把，两个属性var value int //定义全局变量，模拟共享数据// 左写右读
// <-chan int 读
func readGo(index int) {for {rwMutex.RLock() //以读模式加锁 channel和读锁不能同时存在num := valuefmt.Printf("----%dth 读 go程，读出：%d\n", index, num)//time.Sleep(time.Second)rwMutex.RUnlock() //以读模式写锁}
}// chan<- int 写
func writeGo(index int) {for {//生成随机数num := rand.Intn(1000)rwMutex.Lock() //以写模式加锁value = num    //写进去fmt.Printf("%dth 写go程，写入：%d\n", index, num)//time.Sleep(time.Millisecond * 300) // 放大实验现象rwMutex.Unlock() //解锁}
}func main() {// 播种随机数种子rand.Seed(time.Now().UnixNano())for i := 0; i < 5; i++ {go readGo(i + 1)}for i := 0; i < 5; i++ {go writeGo(i + 1)}for true {}
}

读写锁—对应channel

package mainimport ("fmt""math/rand""time"
)var value int //定义全局变量，模拟共享数据// 左写右读
// <-chan int 读
func readGo(ch <-chan int, index int) {for {num := <-ch //从channel中读取数据fmt.Printf("----%dth 读 go程，读出：%d\n", index, num)time.Sleep(time.Second)}
}// chan<- int 写
func writeGo(ch chan<- int, index int) {for {//生成随机数num := rand.Intn(1000)ch <- num //写进去fmt.Printf("%dth 写go程，写入：%d\n", index, num)time.Sleep(time.Millisecond * 300) // 放大实验现象}
}func main() {// 播种随机数种子rand.Seed(time.Now().UnixNano())ch := make(chan int)for i := 0; i < 5; i++ {go readGo(ch, i+1)}for i := 0; i < 5; i++ {go writeGo(ch, i+1)}for true {}
}

生产者消费者模型回顾

package mainimport ("fmt""math/rand""time"
)// 左写
func producer(out chan<- int, index int) {for i := 0; i < 50; i++ {num := rand.Intn(800)fmt.Printf("生产者%dth，生成:%d\n", index, num)out <- num}close(out)
}// 右读
func consumer(in <-chan int, index int) {for i := range in {fmt.Printf("-------消费者%dth，消费:%d\n", index, i)//time.Sleep(time.Millisecond * 300)}
}func main() {product := make(chan int)rand.Seed(time.Now().UnixNano())for i := 0; i < 5; i++ {go producer(product, i+1)}for i := 0; i < 5; i++ {go consumer(product, i+1)}for {}
}

在上面的代码中，加了一个消费者，同时在consumer方法中，将数据取出来后，又进行了一组运算。这时可能会出现一个协程从管道中取出数据，参与加法运算，但是还没有算完另外一个协程又从管道中取出一个数据赋值给了num变量。所以这样累加计算，很有可能出现问题。当然，按照前面的知识，解决这个问题的方法很简单，就是通过加锁的方式来解决。增加生产者也是一样的道理。

另外一个问题，如果消费者比生产者多，仓库中就会出现没有数据的情况。我们需要不断的通过循环来判断仓库队列中是否有数据，这样会造成cpu的浪费。反之，如果生产者比较多，仓库很容易满，满了就不能继续添加数据，也需要循环判断仓库满这一事件，同样也会造成CPU的浪费。

条件变量

条件变量的作用并不保证在同一时刻仅有一个协程（线程）访问某个共享的数据资源，而是在对应的共享数据的状态发生变化时，通知阻塞在某个条件上的协程（线程）。条件变量不是锁，在并发中不能达到同步的目的，因此条件变量总是与锁一块使用。
例如，我们上面说的，如果仓库队列满了，我们可以使用条件变量让生产者对应的goroutine暂停（阻塞），但是当消费者消费了某个产品后，仓库就不再满了，应该唤醒（发送通知给）阻塞的生产者goroutine继续生产产品。
GO标准库中的sys.Cond类型代表了条件变量。条件变量要与锁（互斥锁，或者读写锁）一起使用。成员变量L代表与条件变量搭配使用的锁。

type Cond struct {noCopy noCopy// L is held while observing or changing the conditionL Lockernotify  notifyListchecker copyChecker
}

对应的有3个常用方法，Wait，Signal，Broadcast。
1)func (c *Cond) Wait()
该函数的作用可归纳为如下三点：
a)阻塞等待条件变量满足
b)释放已掌握的互斥锁相当于cond.L.Unlock()。 注意：两步为一个原子操作。
c)当被唤醒，Wait()函数返回时，解除阻塞并重新获取互斥锁。相当于cond.L.Lock()
2)func (c *Cond) Signal()
单发通知，给一个正等待（阻塞）在该条件变量上的goroutine（线程）发送通知。
3)func (c *Cond) Broadcast()
广播通知，给正在等待（阻塞）在该条件变量上的所有goroutine（线程）发送通知。

条件变量：

本身不是锁！！！ 但经常与锁结合使用！！使用流程：1.  创建 条件变量： var cond    sync.Cond2.  指定条件变量用的 锁：  cond.L = new(sync.Mutex)3.  cond.L.Lock()	给公共区加锁（互斥量）4.  判断是否到达 阻塞条件（缓冲区满/空）	—— for 循环判断for  len(ch) == cap(ch) {   cond.Wait() —— 1) 阻塞 2) 解锁 3) 加锁5.  访问公共区 —— 读、写数据、打印 6.  解锁条件变量用的 锁  cond.L.Unlock()7.  唤醒阻塞在条件变量上的 对端。 signal()  Broadcast()

条件变量使用原理分析

在这里插入图片描述

条件变量生产者消费者–主要是串行

package mainimport ("fmt""math/rand""sync""time"
)var cond sync.Cond //定义全部条件变量// 左写
func producer(out chan<- int, index int) {for {//先加锁cond.L.Lock()//判断缓冲区是否满if len(out) == 5 {cond.Wait() //1 阻塞，释放刚才的锁，唤醒以后重新加锁}num := rand.Intn(800)out <- numfmt.Printf("生产者%dth，生成:%d\n", index, num)//返回公共区结束，并且打印结束，解锁cond.L.Unlock()//唤醒阻塞在条件变量上的消费者cond.Signal()time.Sleep(time.Millisecond * 200)}
}// 右读
func consumer(in <-chan int, index int) {for {//先加锁cond.L.Lock()//判断缓冲器是否为空if len(in) == 0 {cond.Wait()}num := <-infmt.Printf("-------消费者%dth，消费:%d\n", index, num)//访问公共区结束后，解锁cond.L.Unlock()//唤醒 阻塞在条件变量上的生产者cond.Signal()time.Sleep(time.Millisecond * 200)}
}func main() {product := make(chan int, 6)rand.Seed(time.Now().UnixNano())//指定条件变量使用的锁cond.L = new(sync.Mutex) //互斥锁，初值0 未加锁状态for i := 0; i < 5; i++ {go producer(product, i+1)}for i := 0; i < 5; i++ {go consumer(product, i+1)}for {}
}

判断wait使用for的原因分析—主要是并行

package mainimport ("fmt""math/rand""sync""time"
)var cond sync.Cond //定义全部条件变量// 左写
func producer(out chan<- int, index int) {for {//先加锁cond.L.Lock()//判断缓冲区是否满for len(out) == 5 { //如果有多个并行就要使用forcond.Wait() //1 阻塞，释放刚才的锁，唤醒以后重新加锁}num := rand.Intn(800)out <- numfmt.Printf("生产者%dth，生成:%d\n", index, num)//返回公共区结束，并且打印结束，解锁cond.L.Unlock()//唤醒阻塞在条件变量上的消费者cond.Signal()time.Sleep(time.Millisecond * 200)}
}// 右读
func consumer(in <-chan int, index int) {for {//先加锁cond.L.Lock()//判断缓冲器是否为空for len(in) == 0 {cond.Wait()}num := <-infmt.Printf("-------消费者%dth，消费:%d\n", index, num)//访问公共区结束后，解锁cond.L.Unlock()//唤醒 阻塞在条件变量上的生产者cond.Signal()time.Sleep(time.Millisecond * 200)}
}func main() {product := make(chan int, 6)rand.Seed(time.Now().UnixNano())//指定条件变量使用的锁cond.L = new(sync.Mutex) //互斥锁，初值0 未加锁状态for i := 0; i < 5; i++ {go producer(product, i+1)}for i := 0; i < 5; i++ {go consumer(product, i+1)}for {}
}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Ubuntu安装中文拼音输入法

Ubuntu安装中文拼音输入法

ubuntu安装中文拼音输入法 ubuntu版本为23.04 1、安装中文语言包 首先安装中文输入法必须要让系统支持中文语言&#xff0c;可以在 Language Support 中安装中文语言包。 添加或删除语音选项&#xff0c;添加中文简体&#xff0c;然后会有Applying changes的对话框&#x…
阅读更多...
vue 把echarts封装成一个方法 并且从后端读取数据 +转换数据格式 =动态echarts 联动echarts表

vue 把echarts封装成一个方法 并且从后端读取数据 +转换数据格式 =动态echarts 联动echarts表

1.把echarts 在 methods 封装成一个方法mounted 在中调用 折线图 和柱状图 mounted调用下边两个方法 mounted(){//最早获取DOM元素的生命周期函数 挂载完毕console.log(mounted-id , document.getElementById(charts))this.line()this.pie()},methods里边的方法 line() {// …
阅读更多...
在Android studio 创建Flutter项目运行出现问题总结

在Android studio 创建Flutter项目运行出现问题总结

在Android studio 中配置Flutter出现的问题 A problem occurred configuring root project ‘android’出现这个问题。解决办法 首先找到flutter配置的位置 在D:\xxx\flutter\packages\flutter_tools\gradle位置中的flutter.gradle buildscript { repositories { googl…
阅读更多...
3D目标检测框架 MMDetection3D环境搭建 docker篇

3D目标检测框架 MMDetection3D环境搭建 docker篇

本文介绍如何搭建3D目标检测框架&#xff0c;使用docker快速搭建MMDetection3D的开发环境&#xff0c;实现视觉3D目标检测、点云3D目标检测、多模态3D目标检测等等。 需要大家提前安装好docker&#xff0c;并且docker版本> 19.03。 1、下载MMDetection3D源码 https://gith…
阅读更多...
《Linux运维总结：Centos7.6之OpenSSH7.4升级版本至9.4》

《Linux运维总结：Centos7.6之OpenSSH7.4升级版本至9.4》

一、环境信息 操作系统&#xff1a;Centos7.6.1810 OpenSSH_7.4p1, OpenSSL 1.0.2k-fips 如下图所示&#xff1a; 注意&#xff1a;升级后由于加密算法的区别&#xff0c;低版本的SSH工具可能无法连接&#xff0c;建议改用Xshell7或SecureCRT9.0以上版本。 二、注意事项 1、检…
阅读更多...
Centos安装显卡

Centos安装显卡

1、安装基础环境 yum -y install epel-release yum -y install gcc kernel-devel kernel-headers 2.对应内核版本 yum info kernel-devel kernel-headers Cat /proc/version 3、yum安装版本不对应。则去官网手动下载 离线安装对应的rpm&#xff1a; https://pkgs.org/dow…
阅读更多...
如何代码降重

如何代码降重

目录 一、使用的相关工具二、冗余代码的分类和压缩策略2.1 无用代码2.2 重复代码2.3 相似代码 三、长久治理机制3.1 git-hooks 一、使用的相关工具 以下工具都有各自详细说明的文档。除非有必要&#xff0c;下文不再对其相关使用作详细说明。 仓库代码查重工具&#xff1a;http…
阅读更多...
Python（八十七）函数的定义与调用

Python（八十七）函数的定义与调用

❤️ 专栏简介&#xff1a;本专栏记录了我个人从零开始学习Python编程的过程。在这个专栏中&#xff0c;我将分享我在学习Python的过程中的学习笔记、学习路线以及各个知识点。 ☀️ 专栏适用人群 &#xff1a;本专栏适用于希望学习Python编程的初学者和有一定编程基础的人。无…
阅读更多...
九芯电子丨语音智能风扇，助您畅享智慧生活

九芯电子丨语音智能风扇，助您畅享智慧生活

回忆童年时期的传统机械风扇&#xff0c;那“古老”的扇叶连摆动看起来是那么吃力。在一个闷热的夏夜&#xff0c;风扇的噪音往往令人印象深刻。但在今天&#xff0c;静音家用风扇已取代了传统的机械风扇。与此同时&#xff0c;随着智能化的发展&#xff0c;智能家居已逐渐成为…
阅读更多...
[计算机入门] 电源选项设置

[计算机入门] 电源选项设置

3.10 电源选项设置 有时候我们的电脑一段时间没有用&#xff0c;会自己关掉屏幕或者直接睡眠&#xff0c;这是电源选项没有设置好导致的。 1、打开控制面板&#xff0c;打开其中的电源选项 2、点击左侧上方的选择关闭显示器的时间 3、进入到编辑计划设置界面&#xff0c;在…
阅读更多...
大数据学习1.1-Centos8网络配置

大数据学习1.1-Centos8网络配置

1.查看虚拟网卡 2.配置网络信息 打勾处取消 记住箭头的数字 3.修改 网络连接 4.进入虚拟网络 5.进入属性 6.修改IPv4 5.将iIP和DNS进行修改 6.配置网络信息-进入修改网络配置文件 # 进入root用户 su root # 进入网络配置文件 cd /etc/sysconfig/network-scripts/ # 修改网络配…
阅读更多...
thrift的简单使用

thrift的简单使用

写在前面 本文一起看下一种由facebook出品的rpc框架thrift。 源码 。 1&#xff1a;开发步骤 1:编写thrift idl文件 2&#xff1a;根据thrift idl文件生成java模板代码 3&#xff1a;继承模板代码的*.Iface接口给出server的具体服务实现 4&#xff1a;使用模板的HelloWorldSe…
阅读更多...
综合管廊安全监测，助力市政管廊智能化管理

综合管廊安全监测，助力市政管廊智能化管理

综合管廊是一种集管线维护、建设、管理于一体的地下综合通道&#xff0c;可以将电力、通讯、燃气、供热、供水等工程管线集于一体&#xff0c;综合管廊对于城市建设具有重要意义&#xff0c;可以防止管线破裂&#xff0c;杜绝反复开挖路面&#xff0c;有效缓解交通拥堵&#xf…
阅读更多...
散列查找—

散列查找—

1.除数取余法 2.直接定址法 3.平方取中法 处理冲突的方法 1.开放定址法 查找效率分析 2.平方探测法 3.伪随机序列法 4.再散列法
阅读更多...
三步实现Mybatis（Mybatis-Plus）多数据源配置

三步实现Mybatis（Mybatis-Plus）多数据源配置

前言 要实现多数据源可以采用dynamic-datasource或者mybatis-mate&#xff0c;本文就以dynamic-datasource为例 dynamic-datasource简介 springboot 快速集成多数据源的启动器 使用文档(opens new window) 支持 数据源分组 &#xff0c;适用于多种场景 纯粹多库 读写分离 一主…
阅读更多...
基于Python和mysql开发的看图猜成语微信小程序(源码+数据库+程序配置说明书+程序使用说明书)

基于Python和mysql开发的看图猜成语微信小程序(源码+数据库+程序配置说明书+程序使用说明书)

一、项目简介 本项目是一套基于Python和mysql开发的看图猜成语微信小程序&#xff0c;主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的Python学习者。 包含&#xff1a;项目源码、项目文档、数据库脚本等&#xff0c;该项目附带全部源码可作为毕设使用。 项目都…
阅读更多...
netty之ByteBuf

netty之ByteBuf

Java NIO 提供了 ByteBuffer 作为它的字节容器&#xff0c;但是这个类使用起来过于复杂&#xff0c;而且也有些繁琐。ByteBuf是对java ByteBuffer的封装。 两个索引 ByteBuf有两个重要的索引&#xff0c;readerIndex和writeIndex。一个用于读取一个用于写入。这两个值初始值都…
阅读更多...
adb操作及常用命令

adb操作及常用命令

问题&#xff1a;no devices/emulators found&#xff1a;adb devices 没有连接的设备 解决方案&#xff1a; 大概率是因为usb调试功能没有打开&#xff0c;可以查看手机设备是否开启usb调试功能 Android若未开启&#xff0c;可通过设置-关于手机&#xff0c;连续点击版本号7…
阅读更多...
小程序自定义导航栏

小程序自定义导航栏

小程序自定义导航栏&#x1f424;&#x1f424; js data: {statusBarHeight: wx.getSystemInfoSync().statusBarHeight, // 状态栏高度navBarHeight: 44, // 导航栏高度},getSystemInfo() {//获取当前设备信息wx.getSystemInfo({success: res > {// 获取胶囊按钮信息let men…
阅读更多...
Linux下的Docker安装，以Ubuntu为例

Linux下的Docker安装，以Ubuntu为例

Docker是一种流行的容器化平台&#xff0c;它能够简化应用程序的部署和管理。 Docker安装 1、检查卸载老版本Docker&#xff08;为保证安装正确&#xff0c;尽量在安装前先进行一次卸载&#xff09; apt-get remove docker docker-engine docker.io containerd runc 2、Dock…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023