Go语言并发编程 互斥锁详情
1、互斥锁Mutex
1.1 Mutex介绍
Go
语言的同步工具主要由 sync
包提供,互斥锁 (Mutex
) 与读写锁 (RWMutex
) 就是sync
包中的方法。
互斥锁可以用来保护一个临界区,保证同一时刻只有一个 goroutine
处于该临界区内。主要包括锁定(Lock
方法)和解锁(Unlock
方法)两个操作,首先对进入临界区的goroutine
进行锁定,离开时进行解锁。
使用互斥锁 (Mutex)时要注意以下几点:
- 不要重复锁定互斥锁,否则会阻塞,也可能会导致死锁(
deadlock
); - 要对互斥锁进行解锁,这也是为了避免重复锁定;
- 不要对未锁定或者已解锁的互斥锁解锁;
- 不要在多个函数之间直接传递互斥锁,
sync.Mutex
类型属于值类型,将它传给一个函数时,会产生一个副本,在函数中对锁的操作不会影响原锁
总之,一个互斥锁只用来保护一个临界区,加锁后记得解锁,对于每一个锁定操作,都要有且只有一个对应的解锁操作,也就是加锁和解锁要成对出现,最保险的做法时使用defer
语句解锁。
1.2 Mutex使用实例
下面的代码模拟取钱和存钱操作:
package main import ( "flag" "fmt" "sync" ) var ( mutex sync.Mutex balance int protecting uint // 是否加锁 sign = make(chan struct{}, 10) //通道,用于等待所有goroutine ) // 存钱 func deposit(value int) { defer func() { sign <- struct{}{} }() if protecting == 1 { mutex.Lock() defer mutex.Unlock() } fmt.Printf("余额: %d\n", balance) balance += value fmt.Printf("存 %d 后的余额: %d\n", value, balance) fmt.Println() } // 取钱 func withdraw(value int) { defer func() { sign <- struct{}{} }() if protecting == 1 { mutex.Lock() defer mutex.Unlock() } fmt.Printf("余额: %d\n", balance) balance -= value fmt.Printf("取 %d 后的余额: %d\n", value, balance) fmt.Println() } func main() { for i:=0; i < 5; i++ { go withdraw(500) // 取500 go deposit(500) // 存500 } for i := 0; i < 10; i++ { <-sign } fmt.Printf("当前余额: %d\n", balance) } func init() { balance = 1000 // 初始账户余额为1000 flag.UintVar(&protecting, "protecting", 0, "是否加锁,0表示不加锁,1表示加锁") }
上面的代码中,使用了通道来让主 goroutine 等待其他 goroutine 运行结束,每个子goroutine在运行结束之前向通道发送一个元素,主
goroutine
在最后从这个通道接收元素,接收次数与子goroutine个数相同。接收完后就会退出主goroutine。
代码使用协程实现多次(5次)对一个账户进行存钱和取钱的操作,先来看不加锁的情况
余额: 1000
存 500 后的余额: 1500
余额: 1000
取 500 后的余额: 1000
余额: 1000
存 500 后的余额: 1500
余额: 1000
取 500 后的余额: 1000
余额: 1000
存 500 后的余额: 1500
余额: 1000
取 500 后的余额: 1000
余额: 1000
取 500 后的余额: 500
余额: 1000
存 500 后的余额: 1000
余额: 1000
取 500 后的余额: 500
余额: 1000
存 500 后的余额: 1000
当前余额: 1000
可以看到出现了混乱,比如第二次1000的余额取500后还是1000,这种对同一资源的竞争出现了竞态条件(Race Condition)。
下面来看加锁的执行结果:
余额: 1000
取 500 后的余额: 500余额: 500
存 500 后的余额: 1000余额: 1000
取 500 后的余额: 500余额: 500
存 500 后的余额: 1000余额: 1000
取 500 后的余额: 500余额: 500
存 500 后的余额: 1000余额: 1000
存 500 后的余额: 1500余额: 1500
取 500 后的余额: 1000余额: 1000
取 500 后的余额: 500余额: 500
存 500 后的余额: 1000当前余额: 1000
加锁后就正常了。
下面介绍更细化的互斥锁:读/写互斥锁RWMutex
。
2、读写锁RWMutex
2.1 RWMutex介绍
读/写互斥锁RWMutex
包含了读锁和写锁,分别对共享资源的“读操作”和“写操作”进行保护。sync.RWMutex
类型中的Lock
方法和Unlock
方法分别用于对写锁进行锁定和解锁,而它的RLock
方法和RUnlock
方法则分别用于对读锁进行锁定和解锁。
有了互斥锁Mutex
,为什么还需要读写锁呢?因为在很多并发操作中,并发读取占比很大,写操作相对较少,读写锁可以并发读取,这样可以提供服务性能。读写锁具有以下特征:
读写锁 | 读锁 | 写锁 |
---|---|---|
读锁 | Yes | No |
写锁 | No | No |
也就是说:
- 如果某个共享资源受到读锁和写锁保护时,其它
goroutine
不能进行写操作。换句话说就是读写操作和写写操作不能并行执行,也就是读写互斥; - 受读锁保护时,可以同时进行多个读操作。
在使用读写锁时,还需要注意:
- 不要对未锁定的读写锁解锁;
- 对读锁不能使用写锁解锁
- 对写锁不能使用读锁解锁
2.2 RWMutex使用实例
改写前面的取钱和存钱操作,添加查询余额的方法:
package main import ( "fmt" "sync" ) // account 代表计数器。 type account struct { num uint // 操作次数 balance int // 余额 rwMu *sync.RWMutex // 读写锁 } var sign = make(chan struct{}, 15) //通道,用于等待所有goroutine // 查看余额:使用读锁 func (c *account) check() { defer func() { sign <- struct{}{} }() c.rwMu.RLock() defer c.rwMu.RUnlock() fmt.Printf("%d 次操作后的余额: %d\n", c.num, c.balance) } // 存钱:写锁 func (c *account) deposit(value int) { defer func() { sign <- struct{}{} }() c.rwMu.Lock() defer c.rwMu.Unlock() fmt.Printf("余额: %d\n", c.balance) c.num += 1 c.balance += value fmt.Printf("存 %d 后的余额: %d\n", value, c.balance) fmt.Println() } // 取钱:写锁 func (c *account) withdraw(value int) { defer func() { sign <- struct{}{} }() c.rwMu.Lock() defer c.rwMu.Unlock() fmt.Printf("余额: %d\n", c.balance) c.num += 1 c.balance -= value fmt.Printf("取 %d 后的余额: %d\n", value, c.balance) fmt.Println() } func main() { c := account{0, 1000, new(sync.RWMutex)} for i:=0; i < 5; i++ { go c.withdraw(500) // 取500 go c.deposit(500) // 存500 go c.check() } for i := 0; i < 15; i++ { <-sign } fmt.Printf("%d 次操作后的余额: %d\n", c.num, c.balance) }
执行结果:
余额: 1000
取 500 后的余额: 5001 次操作后的余额: 500
1 次操作后的余额: 500
1 次操作后的余额: 500
1 次操作后的余额: 500
1 次操作后的余额: 500
余额: 500
存 500 后的余额: 1000余额: 1000
取 500 后的余额: 500余额: 500
存 500 后的余额: 1000余额: 1000
存 500 后的余额: 1500余额: 1500
取 500 后的余额: 1000余额: 1000
取 500 后的余额: 500余额: 500
存 500 后的余额: 1000余额: 1000
取 500 后的余额: 500余额: 500
存 500 后的余额: 100010 次操作后的余额: 1000
读写锁和互斥锁的不同之处在于读写锁把对共享资源的读操作和写操作分开了,可以实现更复杂的访问控制。
总结:
读写锁也是一种互斥锁,它是互斥锁的扩展。在使用时需要注意:
- 加锁后一定要解锁
- 不要重复加锁或者解锁
- 不解锁未锁定的锁
- 不要传递互斥锁
到此这篇关于Go语言并发编程 互斥锁详情的文章就介绍到这了,更多相关Go语言并发编程 互斥锁内容请搜索猪先飞以前的文章或继续浏览下面的相关文章希望大家以后多多支持猪先飞!
原文出处:https://blog.csdn.net/u010698107/article/details/120248679
相关文章
- 这篇文章主要介绍了Go语言压缩和解压缩tar.gz文件的方法,实例分析了使用Go语言压缩文件与解压文件的技巧,具有一定参考借鉴价值,需要的朋友可以参考下...2020-05-03
- 这篇文章主要介绍了go语言使用RC4加密的方法,实例分析了RC4加密的技巧与实现方法,具有一定参考借鉴价值,需要的朋友可以参考下...2020-05-07
- 这篇文章主要介绍了Go语言图片处理和生成缩略图的方法,涉及Go语言针对图片操作的技巧,具有一定参考借鉴价值,需要的朋友可以参考下...2020-05-03
- 这篇文章主要介绍了创建第一个Go语言程序Hello,Go!本文详细的给出项目创建、代码编写的过程,同时讲解了GOPATH、Go install等内容,需要的朋友可以参考下...2020-05-01
- 这篇文章主要介绍了Go语言创建、初始化数组的常见方式,实例汇总了Go语言操作数组的常见技巧,具有一定参考借鉴价值,需要的朋友可以参考下...2020-05-01
- 这篇文章主要介绍了go语言实现文件分割的方法,实例分析了Go语言操作文件的技巧,需要的朋友可以参考下...2020-05-05
- 这篇文章主要介绍了go语言简单的处理http请求的函数,实例分析了Go语言处理http请求的技巧,需要的朋友可以参考下...2020-05-07
- 这篇文章主要介绍了Go语言通过http抓取网页的方法,实例分析了Go语言通过http操作页面的技巧,需要的朋友可以参考下...2020-05-05
- 这篇文章主要介绍了Go语言实现socket的方法,实例分析了socket客户端与服务器端的实现技巧,具有一定参考借鉴价值,需要的朋友可以参考下...2020-05-03
- 这篇文章主要介绍了Java使用synchronized实现互斥锁功能,结合实例形式分析了Java使用synchronized互斥锁功能简单实现方法与操作技巧,需要的朋友可以参考下...2020-05-14
- 这篇文章主要介绍了Go语言里的new函数用法,实例分析了new函数的功能及使用技巧,具有一定参考借鉴价值,需要的朋友可以参考下...2020-05-03
- 这篇文章主要介绍了Go语言实现简单留言板的方法,涉及数据库、模板页面元素等留言板相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下...2020-05-03
- 这篇文章主要为大家介绍了Go语言的网络编程,其中包含了Socket编程,Http编程以及RPC编程,本篇文章是Go语言七篇入门系列文章,有需要的朋友可以借鉴下...2021-11-10
- 这篇文章主要介绍了Go语言扫描目录并获取相关信息的方法,实例分析了Go语言操作目录及文件的技巧,需要的朋友可以参考下...2020-05-05
- 这篇文章主要介绍了Go语言操作mysql数据库简单例子,本文包含插入数据和查询代码实例,需要的朋友可以参考下...2020-05-01
- 这篇文章主要介绍了Go语言计算指定年月天数的方法,实例分析了Go语言操作时间的技巧,具有一定参考借鉴价值,需要的朋友可以参考下...2020-05-05
- 这篇文章主要介绍了Go语言获取本机逻辑CPU数量的方法,实例分析了runtime库的操作技巧,需要的朋友可以参考下...2020-05-05
- 这篇文章主要介绍了Go语言多值替换的HTML模板,实例分析了Go语言多值替换与数组迭代的技巧,具有一定参考借鉴价值,需要的朋友可以参考下...2020-05-05
- 这篇文章主要介绍了Go语言轻量级线程Goroutine用法,实例分析了goroutine使用技巧,需要的朋友可以参考下...2020-05-03
- 这篇文章主要介绍了go语言中if语句用法,以实例形式分析了if语句的定义及使用技巧,非常具有实用价值,需要的朋友可以参考下...2020-05-03