打开Go语言中的那把“锁” 打开Go语言中的那把“锁”

本文主要是介绍打开Go语言中的那把“锁” 打开Go语言中的那把“锁”，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

打开Go语言中的那把“锁”--互斥锁Mutex

操作系统中，关于进程间通信，是一个经常被谈起的问题。笔者也是在《现代操作系统》中第一次接触到这相关的内容。其中关于信号量、互斥锁等并发相关的内容，第一次接触也是从这里开始。

首先我们来看几个概念：
竞争条件：当两个或多个进程读写某些共享数据，而最后的结果取决于进程运行的精确时序，称为“竞争条件”。
注意理解，什么是精确时序？即进程执行的先后顺序会影响到最后的结果。
避免竞争条件，关键是阻止多个进程同时读取共享的数据。
这里我们把，对共享内存进行访问的程序片段称为“临界区”

如果同时访问临界区，就会造成访问或操作出错，为了避免这种情况发生，我们使用了“互斥锁”，限制临界区一次只能有一个进程/线程访问。
在《现代操作系统》一书中也有对互斥锁的描述，关于它的方法使用很简单，就像我们生活中的锁一样，只有开锁和解锁。本文主要从GO语言的角度来讨论互斥锁。
    
我们先来看一下Go语言中互斥锁Mutex的基本用法。

Mutex主要是实现了接口Locker

type Locker interface {
​    Lock()
​    Unlock()
}

这个接口很简单，简而言之就是进入临界区时加锁调用Lock()，离开临界区时解锁调用Unlock()。
关于为什么需要加锁，有并发编程经验的同学都有接触到，这里不做具体说明。
在Go中提供了一个检测并发资源是否有问题的工具race detector，在go run时添加-race就可以体验一下。

在实现一个线程安全的类时，可以采用嵌入字段的方式，将互斥锁sync.Mutex作为struct的一个对象。

我们再来看一下它的实现。总共经历过4个阶段的迭代优化。

1.第一版（使用一个flag字段标记是否持有锁）
2.给新goroutine机会（新的goroutine也能有机会竞争锁）
3.多给goroutine些机会（新来的和被唤醒的有机会获取更多锁）
4.解决饥饿（解决竞争问题，不会让goroutine长久等待）

1：第一版
mutex结构体包含2个字段：
key：用来标示这个排他锁是否被某个goroutine所持有。
sema：信号量变量，用来控制等待goroutine阻塞和休眠。（信号量用来管理等待的goroutine）

Lock()请求锁的时候，如果锁没有被goroutine持有，Lock()方法将key设置为1，这个goroutine就持有了该锁。
如果锁已经被其他goroutine所持有，当前goroutine会把key加1，而且调用semacquire()使用信号量将自己休眠，等锁释放的时候，信号量会将它唤醒。

Unlock()请求释放锁时，会将key减1，如果当前没有其他等待这个锁的goroutine这个方法就返回了。
但是如果还有其他goroutine在等待此锁，它会调用semrelease()利用信号量唤醒等待锁的其他goroutine中的一个。

使用时记住“谁申请谁释放”，Lock()和defer Unlock()搭配使用。
如果是临界区只是函数的一部分，则应该尽快释放。

2：给新goroutine机会
将初版的key字段换成了state字段。
state字段是一个复合型的字段，一个字段包含多个含义。
mutexWaiters(第三位)：等待此锁的goroutine数
mutexWoken(第二位)：唤醒标记（是否有唤醒的goroutine）
mutexLocked（最低位）这个锁是否被持有

加锁逻辑
1.如果没有goroutine持有锁，也没有等待持有锁的goroutine，那这个goroutine就很幸运，可以直接获得锁。
2.如果state不是零值，就通过一个循环进行检测，

请求锁的goroutine有两类，一类是新来请求锁的goroutine，另一类是被唤醒的等待请求锁的goroutine。

锁的状态也有两种，加锁和未加锁。
相对于初版，这次的改动主要就是：新来的goroutine也有机会先获得锁，打破了先来先得的逻辑。

3.多给goroutine些机会：
针对新来的goroutine，或者是被唤醒的goroutine，首次获取不到锁，会自旋获取，尝试一定自旋次数。

4.解决饥饿：
新的goroutine也会获得锁的机会，极端情况下，等待中的goroutine会一直获取不到锁，这就是饥饿问题。
让等待比较长的goroutine更有机会获得锁。

mutex的实现貌似非常复杂，其实主要还是针对饥饿模式和公平性问题，做了一些额外处理。

最后我们看一下比较常见的使用mutex出错的场景。
一.Lock/Unlock不成对
其中缺少Unlock的场景
1.代码中太多的if-else，可能在某个分支漏写了Unlock
2.重构时把Unlock给删除了
3.Unlock误写成了Lock
这种情况意味着其他goroutine永远获取不到锁

2.缺少Lock()的情况（触发panic）

二.复制已使用的mutex
package sync的同步原语，在使用后是不能被复制的。Go在运行时，有死锁的检查机制，使用go vet可以在编译的时候检查。

三.重入

java中的可重入锁，基本行为和互斥锁相同，加了一些扩展。
可重入锁：拥有该锁的线程，再次请求这把锁的话，不会阻塞，而是可以成功返回。只要拥有这把锁就可以一直用。
如何实现一个可重入锁？
1：记录获取锁的goroutine Id
2：提供一个token
可重入锁，解决了代码重入和递归调用带来的死锁问题。同时要求只有持有锁的goroutine可以解锁。
方式一：
0.获取goroutine Id（runtime.Stack方法获取）
1.先获取TLS对象
2.获取goroutine结构中的g指针
3.从g指针中取出goroutine id
方式二：通过用户传入的token，替换方式一的goroutine Id

三.死锁
两个或两个以上的进程（线程、goroutine）争夺共享资源而处于一种互相等待的状态,就被成为“死锁”。
死锁产生的4个条件：
1.互斥
2.持有和等待
3.不可剥夺（资源只能由持有它的goroutine来释放）
4.环路等待

本文针对go语言中的mutex只做了一个简单的介绍，主要参考了现代操作系统和Go并发编程实战课的内容，有需要的同学可以再依此来发散扩展。

这篇关于打开Go语言中的那把“锁” 打开Go语言中的那把“锁”的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！