专栏首页流浪猫的golanggolang mutex锁的竞争关系浅析

golang mutex锁的竞争关系浅析

刚才对golang的锁关系进行 一番思索,想着协程获取golang 对象锁的,是按先按时间先后顺序获取的,其实不然。下面请看代码,顺带写了2种读写锁的应用。

package main

import (
	"sync"
	"fmt"
	"time"
)
//开启10个线程  同时去竞争一个互斥锁 谁有能力谁上

var mutex *sync.Mutex;
var  ch chan int


func main() {
	mutex=new(sync.Mutex)
	fmt.Println("start")
	ch=make(chan int )
	for i:=0; i<10; i++ {
		go TestMutex(ch,i)
	}
	for i:=0; i<10; i++ {
	<-ch
	}
}

func TestMutex(ch chan int,index int)  {
	fmt.Println("to enter mutex","index=",index)
	mutex.Lock();
	defer mutex.Unlock()
	defer fmt.Println("unLock","index=",index)
	fmt.Println("in mutex","index=",index)
	time.Sleep(2*time.Second)
	ch<-1

运行结果如下:

start
to enter mutex index= 3
to enter mutex index= 9
in mutex index= 3
to enter mutex index= 5
to enter mutex index= 6
to enter mutex index= 7
to enter mutex index= 8
to enter mutex index= 1
to enter mutex index= 0
to enter mutex index= 4
to enter mutex index= 2
unLock index= 3
in mutex index= 9
unLock index= 9
in mutex index= 5
unLock index= 5
in mutex index= 6
unLock index= 6
in mutex index= 7
unLock index= 7
in mutex index= 8
unLock index= 8
in mutex index= 1
unLock index= 1
in mutex index= 0
unLock index= 0
in mutex index= 4
in mutex index= 2
unLock index= 4
unLock index= 2
简要分析:通过运行结果发现所有协程都开始执行,但是进入锁的协程编号变成了3,不是按12345678的顺序获取互斥锁
总结:协程获取锁先后顺序不是按时间来获取,而是竞争关系谁有能力谁上

读写锁(RWmutex)的模型一: 多个协程一起读

var RWmutex *sync.RWMutex;
var  RWch chan int

func main() {
   RWmutex=new(sync.RWMutex)
   fmt.Println("start")
   RWch=make(chan int )
   for i:=0; i<10; i++ {
      go TestRWMutex(i)
   }
   for i:=0; i<10; i++ {
      <-RWch
   }
}

func TestRWMutex(index int)  {
   fmt.Println("进入读写锁,准备读点东西","index=",index)
   RWmutex.RLock();
   //读取数据
   fmt.Println("读点东西..","index=",index)
   time.Sleep(4*time.Second)
   RWmutex.RUnlock()
   fmt.Println("离开读写锁..","index=",index)
   RWch<-1
}

运行结果:start start 进入读写锁,准备读点东西 index= 0 进入读写锁,准备读点东西 index= 2 读点东西.. index= 2 进入读写锁,准备读点东西 index= 4 读点东西.. index= 4 进入读写锁,准备读点东西 index= 9 读点东西.. index= 9 进入读写锁,准备读点东西 index= 3 读点东西.. index= 3 进入读写锁,准备读点东西 index= 8 读点东西.. index= 8 读点东西.. index= 0 进入读写锁,准备读点东西 index= 1 读点东西.. index= 1 进入读写锁,准备读点东西 index= 7 读点东西.. index= 7 进入读写锁,准备读点东西 index= 6 读点东西.. index= 6 进入读写锁,准备读点东西 index= 5 读点东西.. index= 5 离开读写锁.. index= 4 离开读写锁.. index= 3 离开读写锁.. index= 9 离开读写锁.. index= 2 离开读写锁.. index= 7 离开读写锁.. index= 1 离开读写锁.. index= 5 离开读写锁.. index= 0 离开读写锁.. index= 6

离开读写锁.. index= 8

简要分析:读锁可连续加上。

读写锁模型 写入得时候保护,只有一个协程能写其他的协程不能写

package main

import (
	"fmt"
	"time"
	"sync"
)
var RWWmutex *sync.RWMutex;
var  RWWch chan int
// 读写模型2, 写的时候什么也做不了,
//也就是写保护
func main() {
	RWWmutex=new(sync.RWMutex)
	fmt.Println("start")
	RWWch=make(chan int )
	for i:=0; i<10; i++ {
		go TestRWWMutex(RWWch,i)
	}
	for i:=0; i<10; i++ {
		<-RWWch
	}
}

func TestRWWMutex(ch chan int,index int) {
	fmt.Println("进入写锁","index=",index)
	RWWmutex.Lock();

	//写东西..
	fmt.Println("正字写东西.....","index=",index)
	time.Sleep(1*time.Second)
	RWWmutex.Unlock()
	fmt.Println("离开写锁","index=",index)
	RWWch<-1
}

运行结果:

start 进入写锁 index= 0 进入写锁 index= 1 进入写锁 index= 6 进入写锁 index= 7 进入写锁 index= 2 进入写锁 index= 3 进入写锁 index= 9 正字写东西..... index= 0 进入写锁 index= 4 进入写锁 index= 5 进入写锁 index= 8 离开写锁 index= 0 正字写东西..... index= 1 正字写东西..... index= 6 离开写锁 index= 1 正字写东西..... index= 7 离开写锁 index= 6 离开写锁 index= 7 正字写东西..... index= 2 离开写锁 index= 2 正字写东西..... index= 3 离开写锁 index= 3 正字写东西..... index= 9 离开写锁 index= 9 正字写东西..... index= 4 离开写锁 index= 4 正字写东西..... index= 5 离开写锁 index= 5 正字写东西..... index= 8

离开写锁 index= 8

不难看出 写东西的时候受到了锁的保护

模型4:读写混合进行

package main

import (
	"sync"
	"fmt"
	"time"
)

//读写同时发生的模型
//读的时候的写 NO
//写的时候读 NO


var WR_Wmutex *sync.RWMutex;
//var WR_Rmutex *sync.RWMutex;
var  WRch chan int

func main() {
	WR_Wmutex=new(sync.RWMutex)
	fmt.Println("start")
	WRch=make(chan  int )

	for i:=0;i<5;i++  {
		go TestRW_WMutex(i)
		go TestRW_RMutex(i)
	}
	for i:=0;i<10 ; i++ {
		<-WRch
	}
}

func TestRW_WMutex(index int) {
	WR_Wmutex.Lock();
	//写东西..
	fmt.Println("BBB 测试写,正在写东西.....","index=",index)
	time.Sleep(1*time.Second)
	fmt.Println("BBB 测试写,即将离开写锁","index=",index)
	WR_Wmutex.Unlock()

	WRch<-1
}

func TestRW_RMutex(index int) {
	WR_Wmutex.RLock();
	//写东西..
	fmt.Println("AAA 测试读,正在读东西.....","index=",index)
	time.Sleep(1*time.Second)
	fmt.Println("AAA 测试读,即将离开读锁","index=",index)
	WR_Wmutex.RUnlock()

	WRch<-1
}

运行结果:

2018-03-12 11:21:59 BBB 测试写,正在写东西..... index= 0 2018-03-12 11:22:00 BBB 测试写,即将离开写锁 index= 0 2018-03-12 11:22:00 AAA 测试读,正在读东西..... index= 4 2018-03-12 11:22:00 AAA 测试读,正在读东西..... index= 2 2018-03-12 11:22:00 AAA 测试读,正在读东西..... index= 3 2018-03-12 11:22:00 AAA 测试读,正在读东西..... index= 0 2018-03-12 11:22:00 AAA 测试读,正在读东西..... index= 1 2018-03-12 11:22:01 AAA 测试读,即将离开读锁 index= 4 2018-03-12 11:22:01 AAA 测试读,即将离开读锁 index= 2 2018-03-12 11:22:01 AAA 测试读,即将离开读锁 index= 1 2018-03-12 11:22:01 AAA 测试读,即将离开读锁 index= 3 2018-03-12 11:22:01 AAA 测试读,即将离开读锁 index= 0 2018-03-12 11:22:01 BBB 测试写,正在写东西..... index= 1 2018-03-12 11:22:02 BBB 测试写,即将离开写锁 index= 1 2018-03-12 11:22:02 BBB 测试写,正在写东西..... index= 2 2018-03-12 11:22:03 BBB 测试写,即将离开写锁 index= 2 2018-03-12 11:22:03 BBB 测试写,正在写东西..... index= 3 2018-03-12 11:22:04 BBB 测试写,即将离开写锁 index= 3 2018-03-12 11:22:04 BBB 测试写,正在写东西..... index= 4

2018-03-12 11:22:05 BBB 测试写,即将离开写锁 index= 4

改变一下读写锁加入的顺序,先加读锁,后加写锁.

func main() {
	WR_Wmutex=new(sync.RWMutex)
	fmt.Println("start")
	WRch=make(chan  int )

	for i:=0;i<5;i++  {
		go TestRW_RMutex(i)
		go TestRW_WMutex(i)
	}
	for i:=0;i<10 ; i++ {
		<-WRch
	}
}

运行结果:

2018-03-12 11:18:19 AAA 测试读,正在读东西..... index= 0 2018-03-12 11:18:20 AAA 测试读,即将离开读锁 index= 0 2018-03-12 11:18:20 BBB 测试写,正在写东西..... index= 4 2018-03-12 11:18:21 BBB 测试写,即将离开写锁 index= 4 2018-03-12 11:18:21 AAA 测试读,正在读东西..... index= 4 2018-03-12 11:18:21 AAA 测试读,正在读东西..... index= 1 2018-03-12 11:18:21 AAA 测试读,正在读东西..... index= 2 2018-03-12 11:18:21 AAA 测试读,正在读东西..... index= 3 2018-03-12 11:18:22 AAA 测试读,即将离开读锁 index= 3 2018-03-12 11:18:22 AAA 测试读,即将离开读锁 index= 2 2018-03-12 11:18:22 AAA 测试读,即将离开读锁 index= 4 2018-03-12 11:18:22 AAA 测试读,即将离开读锁 index= 1 2018-03-12 11:18:22 BBB 测试写,正在写东西..... index= 0 2018-03-12 11:18:23 BBB 测试写,即将离开写锁 index= 0 2018-03-12 11:18:23 BBB 测试写,正在写东西..... index= 1 2018-03-12 11:18:24 BBB 测试写,即将离开写锁 index= 1 2018-03-12 11:18:24 BBB 测试写,正在写东西..... index= 2 2018-03-12 11:18:25 BBB 测试写,即将离开写锁 index= 2 2018-03-12 11:18:25 BBB 测试写,正在写东西..... index= 3 2018-03-12 11:18:26 BBB 测试写,即将离开写锁 index= 3

运行结果分析:读的时候不能写,可以多次读;写的时候不能读,也不能写。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • mongodb 学习随笔 及golang 连接mongoDB

    Mogondb 不支持事务。所有有事务要求的需求慎用,比如银行的转账操作慎用,转1个亿美金,因为网络,电力的故障导致交易没有完成,不能回滚,交易无法撤回。所有慎...

    地球流浪猫
  • golang优雅的面向对象

    大家都知道,面向对象的3大基本特征:封装,继承,多态。 封装: 封装是指将某事物的属性和行为包装到对象中,这个对象只对外公布需要公开的属性和行为,而这个公布...

    地球流浪猫
  • nginx反向代理和负载均衡算法介绍

    1 全局块:配置影响nginx全局的指令。一般有运行nginx服务器的用户组,nginx进程pid存放路径,日志存放路径,配置文件引入,允许生成worker ...

    地球流浪猫
  • Apache2为什么会自动加载index.php

    我直接输入域名后,Apache2自动加载了对应目录下的index.php, 这是怎么做到的?

    Jerry Wang
  • 精解四大集合框架:List核心知识总结

    Java集合框架早也是个老话题了,今天主要是总结一下关于Java中的集合框架List的核心知识点。肯定有人会问,这篇写的是List那接下来就还有三篇?是的,ja...

    田维常
  • 2018全球Top 1000 计算机科学家h指数发布,中国29名学者上榜!

    【新智元导读】Guide2Research网站日前发布了2018年全球计算机科学和电子领域H-index排名前1000的科学家。密歇根州立大学的 Anil K....

    新智元
  • python冒泡法排序算法

    冒泡法排序思想:将数组中的数据两两进行比较,每次将较大的数据交换到后面,直到大数沉底,小数冒出。

    py3study
  • 蓝桥杯之趣味算式

    匪警请拨110,即使手机欠费也可拨通! 为了保障社会秩序,保护人民群众生命财产安全,警察叔叔需要与罪犯斗智斗勇,因而需要经常性地进行体力训练和智力训...

    用户4492257
  • Java进阶--深入理解ArrayList实现原理

    Tanyboye
  • MATLAB实现Excel中lookup函数查找匹配功能

    在Excel中的lookup函数很容易可以实现以下功能:根据左侧序号对应的姓名匹配右侧相同序号的姓名。

    matlab爱好者

扫码关注云+社区

领取腾讯云代金券