自旋锁以及Java中的自旋锁的实现

深藏阁楼爱情的钟 2022-05-17 04:53 265阅读 0赞

## 什么是自旋锁 ##

多线程中，对共享资源进行访问，为了防止并发引起的相关问题，通常都是引入锁的机制来处理并发问题。

获取到资源的线程A对这个资源加锁，其他线程比如B要访问这个资源首先要获得锁，而此时A持有这个资源的锁，只有等待线程A逻辑执行完，释放锁，这个时候B才能获取到资源的锁进而获取到该资源。

这个过程中，A一直持有着资源的锁，那么没有获取到锁的其他线程比如B怎么办？通常就会有两种方式：

1. 一种是没有获得锁的进程就直接进入阻塞（BLOCKING），这种就是互斥锁

2. 另外一种就是没有获得锁的进程，不进入阻塞，而是一直循环着，看是否能够等到A释放了资源的锁。

上述的两种方式，学术上，就有几种不同的定义方式，大学的时候 学习的是C++， 《C++ 11》中就有这样的描述：

自旋锁（spin lock）是一种非阻塞锁，也就是说，如果某线程需要获取锁，但该锁已经被其他线程占用时，该线程不会被挂起，而是在不断的消耗CPU的时间，不停的试图获取锁。

互斥量（mutex）是阻塞锁，当某线程无法获取锁时，该线程会被直接挂起，该线程不再消耗CPU时间，当其他线程释放锁后，操作系统会激活那个被挂起的线程，让其投入运行。

而《linux内核设计与实现》经常提到两种态，一种是内核态，一种是用户态，对于自旋锁来说，自旋锁使线程处于用户态，而互斥锁需要重新分配，进入到内核态。这里大家对内核态和用户态有个初步的认知就行了，用户态比较轻，内核态比较重。用户态和内核态这个也是linux中必备的知识基础，借鉴这个，可以进行很多程序设计语言API上的优化，就比如说javaio的部分，操作io的时候，先是要从用户态，进入内核态，再用内核态去操作输入输出设备的抽象，这里减少用户态到内核态的转换就是新io的一部分优化，后面再聊。

wiki中的定义如下：

**自旋锁**是[计算机科学][Link 1]用于多线程[同步][Link 2]的一种[锁][Link 3]，线程反复检查锁变量是否可用。由于线程在这一过程中保持执行，因此是一种[忙等待][Link 4]。

自旋锁避免了进程上下文的调度开销，因此对于线程只会阻塞很短时间的场合是有效的。因此操作系统的实现在很多地方往往用自旋锁。Windows操作系统提供的轻型[读写锁][Link 5]（SRW Lock）内部就用了自旋锁。显然，单核CPU不适于使用自旋锁，这里的单核CPU指的是单核单线程的CPU，因为，在同一时间只有一个线程是处在运行状态，假设运行线程A发现无法获取锁，只能等待解锁，但因为A自身不挂起，所以那个持有锁的线程B没有办法进入运行状态，只能等到操作系统分给A的时间片用完，才能有机会被调度。这种情况下使用自旋锁的代价很高。（红字部分是我给wiki编辑的词条，单核CPU不适合自旋锁，这个也只是针对单核单线程的情况，现在的技术基本单核都是支持多线程的）

## 为什么要使用自旋锁 ##

互斥锁有一个缺点，他的执行流程是这样的 托管代码  - 用户态代码 - 内核态代码、上下文切换开销与损耗，假如获取到资源锁的线程A立马处理完逻辑释放掉资源锁，如果是采取互斥的方式，那么线程B从没有获取锁到获取锁这个过程中，就要用户态和内核态调度、上下文切换的开销和损耗。所以就有了自旋锁的模式，让线程B就在用户态循环等着，减少消耗。

自旋锁比较适用于锁使用者保持锁时间比较短的情况，这种情况下自旋锁的效率要远高于互斥锁。

## 自旋锁可能潜在的问题 ##

*  过多占用CPU的资源，如果锁持有者线程A一直长时间的持有锁处理自己的逻辑，那么这个线程B就会一直循环等待过度占用cpu资源
 *  递归使用可能会造成死锁，不过这种场景一般写不出来

## CAS ##

就不写术语定义了，简单的理解就是这个CAS是由操作系统定义的，由若干指令组成的，这个操作具有原子性，这些指令如果执行，就会全部执行完，不会被中断。CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。

## CAS的问题 ##

*  经典的CAS的ABA问题，上面提到了CAS操作的时候，要检测值有没有变化，如果一个值原来是A，后来变成了B， 后来又变成了A，CAS会认为没有发生变化。

解决方案：

1. 加版本号   1A - 2B -  3A

2. 对java而言，jdk1.5提供了AtomicStampedReference来解决这个问题

*  只能保证一个共享变量的原子操作

CAS通常是对一个变量来进行原子操作的，所以如果对多个变量进行原子操作就会有问题了。

解决方案

1. 简单粗暴，加锁，反而加入了复杂性，最low的方式

2. 跟上面的加版本号的道理一样，就是将多个变量拼成一个变量（可以拼成一个字符串）

3. 对java而言，jdk1.5 提供了AtomicStampedReference，这个reference 就是个对象引用，把多个变量放在这个对象里即可

## JAVA CAS封装 ##

sun.misc.Unsafe是JDK里面的一个内部类，这个类当中有三个CAS的操作

## JAVA自旋锁应用 ##

Jdk1.5以后，提供了java.util.concurrent.atomic包，这个包里面提供了一组原子类。基本上就是当前获取锁的线程，执行更新的方法，其他线程自旋等待，比如atomicInteger类中的getAndAdd方法内部实际上使用的就是Unsafe的方法。

/**
         * Atomically adds the given value to the current value.
         *
         * @param delta the value to add
         * @return the previous value
         */
        public final int getAndAdd(int delta) {
            return unsafe.getAndAddInt(this, valueOffset, delta);
        }

当然java中的syncronized关键字，在1.5中有了很大的优化，加入了偏隙锁也有人叫偏向锁，主要的实现方式就是在对象头markword中打上线程的信息，这样资源上的锁的获取就偏向了这个线程，后面，会涉及一系列的锁升级的问题，间隙锁 - 轻量锁 - 重量级锁 ，锁升级后面单独抽出来写一篇，这个轻量锁实际上就是使用的也是自旋锁的实现方式。

[Link 1]: https://zh.wikipedia.org/wiki/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%A7%91%E5%AD%A6
[Link 2]: https://zh.wikipedia.org/wiki/%E5%90%8C%E6%AD%A5_%28%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%A7%91%E5%AD%A6%29
[Link 3]: https://zh.wikipedia.org/wiki/%E4%BA%92%E6%96%A5%E9%94%81
[Link 4]: https://zh.wikipedia.org/wiki/%E5%BF%99%E7%AD%89%E5%BE%85
[Link 5]: https://zh.wikipedia.org/wiki/%E8%AF%BB%E5%86%99%E9%94%81