常见面试题之线程中并发锁（二）

超、凢脫俗 2024-03-17 13:31 22阅读 0赞

### 1. 什么是`AQS`？ ###

#### 1.1. 概述 ####

全称是`AbstractQueuedSynchronizer`，是阻塞式锁和相关的同步器工具的框架，它是构建锁或者其他同步组件的基础框架

`AQS`与`Synchronized`的区别

<table> 
 <thead> 
  <tr> 
   <th><strong><code>synchronized</code></strong></th> 
   <th><strong><code>AQS</code></strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>关键字，<code>c++</code>语言实现</td> 
   <td><code>java</code>语言实现</td> 
  </tr> 
  <tr> 
   <td>悲观锁，自动释放锁</td> 
   <td>悲观锁，手动开启和关闭</td> 
  </tr> 
  <tr> 
   <td>锁竞争激烈都是重量级锁，性能差</td> 
   <td>锁竞争激烈的情况下，提供了多种解决方案</td> 
  </tr> 
 </tbody> 
</table>

`AQS`常见的实现类

*  `ReentrantLock` 阻塞式锁
 *  `Semaphore` 信号量
 *  `CountDownLatch` 倒计时锁

#### 1.2. 工作机制 ####

*  在`AQS`中维护了一个使用了`volatile`修饰的`state`属性来表示资源的状态，0表示无锁，1表示有锁
 *  提供了基于`FIFO`的等待队列，类似于`Monitor`的`EntryList`
 *  条件变量来实现等待、唤醒机制，支持多个条件变量，类似于`Monitor`的`WaitSet`

![在这里插入图片描述][cc3e008d04864d4dabc452ac2869fe23.png_pic_center]

>  *  线程0来了以后，去尝试修改`state`属性，如果发现`state`属性是0，就修改`state`状态为1，表示线程0抢锁成功
>  *  线程1和线程2也会先尝试修改`state`属性，发现`state`的值已经是1了，有其他线程持有锁，它们都会到`FIFO`队列中进行等待，
>  *  `FIFO`是一个双向队列，`head`属性表示头结点，`tail`表示尾结点

**如果多个线程共同去抢这个资源是如何保证原子性的呢？**

![在这里插入图片描述][321e0f54296c48aeb3da1a5638fc8964.png_pic_center]

在去修改`state`状态的时候，使用的`cas`自旋锁来保证原子性，确保只能有一个线程修改成功，修改失败的线程将会进入`FIFO`队列中等待

**`AQS`是公平锁吗，还是非公平锁？**

*  新的线程与队列中的线程共同来抢资源，是非公平锁
 *  新的线程到队列中等待，只让队列中的`head`线程获取锁，是公平锁

> 比较典型的`AQS`实现类`ReentrantLock`，它默认就是非公平锁，新的线程与队列中的线程共同来抢资源

### 2. `ReentrantLock`的实现原理 ###

#### 2.1. 概述 ####

`ReentrantLock`翻译过来是可重入锁，相对于`synchronized`它具备以下特点：

*  可中断
 *  可以设置超时时间
 *  可以设置公平锁
 *  支持多个条件变量
 *  与`synchronized`一样，都支持重入

![在这里插入图片描述][27d21e569aa7435a912d1525d1860e5e.png_pic_center]

#### 2.2. 实现原理 ####

`ReentrantLock`主要利用`CAS+AQS`队列来实现。它支持公平锁和非公平锁，两者的实现类似

构造方法接受一个可选的公平参数（默认非公平锁），当设置为`true`时，表示公平锁，否则为非公平锁。公平锁的效率往往没有非公平锁的效率高，在许多线程访问的情况下，公平锁表现出较低的吞吐量。

查看`ReentrantLock`源码中的构造方法：

![在这里插入图片描述][5cf88cfd094e4f7f8384c3753e7b9775.png_pic_center]

提供了两个构造方法，不带参数的默认为非公平

如果使用带参数的构造函数，并且传的值为`true`，则是公平锁

其中`NonfairSync`和`FairSync`这两个类父类都是`Sync`

![在这里插入图片描述][097b177e2e994bd2840d61f6dacea49e.png_pic_center]

而`Sync`的父类是`AQS`，所以可以得出`ReentrantLock`底层主要实现就是基于`AQS`来实现的

![在这里插入图片描述][2cd88103cea545fa96d525bdaf5f8d4f.png_pic_center]

**工作流程**

![在这里插入图片描述][c5b67d91a960406f986ae3590796e871.png_pic_center]

*  线程来抢锁后使用`cas`的方式修改`state`状态，修改状态成功为1，则让`exclusiveOwnerThread`属性指向当前线程，获取锁成功
 *  假如修改状态失败，则会进入双向队列中等待，`head`指向双向队列头部，`tail`指向双向队列尾部
 *  当`exclusiveOwnerThread`为`null`的时候，则会唤醒在双向队列中等待的线程
 *  公平锁则体现在按照先后顺序获取锁，非公平体现在不在排队的线程也可以抢锁

### 3. `synchronized`和`Lock`有什么区别 ? ###

参考回答

*  语法层面
    
     *  `synchronized`是关键字，源码在`jvm`中，用`c++`语言实现
     *  `Lock`是接口，源码由`jdk`提供，用`java`语言实现
     *  使用`synchronized`时，退出同步代码块锁会自动释放，而使用`Lock`时，需要手动调用`unlock`方法释放锁
 *  功能层面
    
     *  二者均属于悲观锁、都具备基本的互斥、同步、锁重入功能
     *  `Lock`提供了许多`synchronized`不具备的功能，例如获取等待状态、公平锁、可打断、可超时、多条件变量
     *  `Lock`有适合不同场景的实现，如`ReentrantLock`，`ReentrantReadWriteLock`
 *  性能层面
    
     *  在没有竞争时，`synchronized`做了很多优化，如偏向锁、轻量级锁，性能不赖
     *  在竞争激烈时，`Lock`的实现通常会提供更好的性能

### 4. 死锁产生的条件是什么？ ###

**死锁**：一个线程需要同时获取多把锁，这时就容易发生死锁

> 例如：
> 
> `t1`线程获得A对象锁，接下来想获取`B`对象的锁
> 
> `t2`线程获得`B`对象锁，接下来想获取`A`对象的锁

代码如下：

package com.dcxuexi.basic;
    
    import static java.lang.Thread.sleep;
    
    public class Deadlock {
        
    
        public static void main(String[] args) {
        
            Object A = new Object();
            Object B = new Object();
            Thread t1 = new Thread(() -> {
        
                synchronized (A) {
        
                    System.out.println("lock A");
                    try {
        
                        sleep(1000);
                    } catch (InterruptedException e) {
        
                        throw new RuntimeException(e);
                    }
                    synchronized (B) {
        
                        System.out.println("lock B");
                        System.out.println("操作...");
                    }
                }
            }, "t1");
    
            Thread t2 = new Thread(() -> {
        
                synchronized (B) {
        
                    System.out.println("lock B");
                    try {
        
                        sleep(500);
                    } catch (InterruptedException e) {
        
                        throw new RuntimeException(e);
                    }
                    synchronized (A) {
        
                        System.out.println("lock A");
                        System.out.println("操作...");
                    }
                }
            }, "t2");
            t1.start();
            t2.start();
        }
    }

控制台输出结果

![在这里插入图片描述][bcda813273a744a0966413f0b4aaf426.png_pic_center]

此时程序并没有结束，这种现象就是死锁现象…线程`t1`持有`A`的锁等待获取`B`锁，线程`t2`持有`B`的锁等待获取`A`的锁。

### 5. 如何进行死锁诊断？ ###

当程序出现了死锁现象，我们可以使用`jdk`自带的工具：`jps`和`jstack`

步骤如下：

第一：查看运行的线程

![在这里插入图片描述][1496aa4950774fa1855e588d17005b72.png_pic_center]

第二：使用`jstack`查看线程运行的情况，下图是截图的关键信息

运行命令：`jstack -l 46032`

![在这里插入图片描述][a703c1c630714851a6d736244d99ac23.png_pic_center]

**其他解决工具，可视化工具**

*  `jconsole`

用于对`jvm`的内存，线程，类 的监控，是一个基于`jmx`的`GUI`性能监控工具

打开方式：`java`安装目录`bin`目录下 直接启动`jconsole.exe`就行

*  `VisualVM`：故障处理工具

能够监控线程，内存情况，查看方法的`CPU`时间和内存中的对 象，已被`GC`的对象，反向查看分配的堆栈

打开方式：`java`安装目录`bin`目录下 直接启动`jvisualvm.exe`就行

### 6. `ConcurrentHashMap` ###

`ConcurrentHashMap`是一种线程安全的高效`Map`集合

底层数据结构：

*  `JDK1.7`底层采用分段的数组+链表实现
 *  `JDK1.8`采用的数据结构跟`HashMap1.8`的结构一样，数组+链表/红黑二叉树。

#### 6.1. `JDK1.7`中`concurrentHashMap` ####

数据结构

![在这里插入图片描述][31f607fb66e8451b8d7c8134e4193b20.png_pic_center]

>  *  提供了一个`segment`数组，在初始化`ConcurrentHashMap`的时候可以指定数组的长度，默认是16，一旦初始化之后中间不可扩容
>  *  在每个`segment`中都可以挂一个`HashEntry`数组，数组里面可以存储具体的元素，`HashEntry`数组是可以扩容的
>  *  在`HashEntry`存储的数组中存储的元素，如果发生冲突，则可以挂单向链表

存储流程

![在这里插入图片描述][57db5fabf6814b7aa15fc3c9e616aec7.png_pic_center]

*  先去计算`key`的`hash`值，然后确定`segment`数组下标
 *  再通过`hash`值确定`hashEntry`数组中的下标存储数据
 *  在进行操作数据的之前，会先判断当前`segment`对应下标位置是否有线程进行操作，为了线程安全使用的是`ReentrantLock`进行加锁，如果获取锁是被会使用`cas`自旋锁进行尝试

#### 6.2. `JDK1.8`中`concurrentHashMap` ####

在`JDK1.8`中，放弃了`Segment`臃肿的设计，数据结构跟`HashMap`的数据结构是一样的：数组+红黑树+链表

采用`CAS + Synchronized`来保证并发安全进行实现

*  `CAS`控制数组节点的添加
 *  `synchronized`只锁定当前链表或红黑二叉树的首节点，只要`hash`不冲突，就不会产生并发的问题 , 效率得到提升

![在这里插入图片描述][3ab577761c094ce89e51a05641e9d6c9.png_pic_center]

### 7. 导致并发程序出现问题的根本原因是什么？ ###

`Java`并发编程三大特性

*  原子性
 *  可见性
 *  有序性

#### （1）原子性 ####

一个线程在`CPU`中操作不可暂停，也不可中断，要不执行完成，要不不执行

比如，如下代码能保证原子性吗？

![在这里插入图片描述][e59bfc3711334226bd0bb9f9f50e0d6d.png_pic_center]

以上代码会出现超卖或者是一张票卖给同一个人，执行并不是原子性的

解决方案：

1.`synchronized`：同步加锁

2.`JUC`里面的`lock`：加锁

![在这里插入图片描述][9c00ff5f4a0c49acb36ca89f97e5a022.png_pic_center]

#### （2）内存可见性 ####

内存可见性：让一个线程对共享变量的修改对另一个线程可见

比如，以下代码不能保证内存可见性

![在这里插入图片描述][6066aba594d646a58cfae3a65a7a4425.png_pic_center]

解决方案：

*  `synchronized`
 *  `volatile`（推荐）
 *  `LOCK`

#### （3）有序性 ####

指令重排：处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的

还是之前的例子，如下代码：

![在这里插入图片描述][eddf566794624a5dbfde1e0acd38cefd.png_pic_center]

解决方案：

*  volatile

[cc3e008d04864d4dabc452ac2869fe23.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/6589cb60137c45ccb0bb7d8b317a1d03.png
[321e0f54296c48aeb3da1a5638fc8964.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/c0534e03b34544f2a1a0b24a156ad47b.png
[27d21e569aa7435a912d1525d1860e5e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/0223faa4312b44cfa1259da37848dbc6.png
[5cf88cfd094e4f7f8384c3753e7b9775.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/2eabdab224104008b86eab421e224fe4.png
[097b177e2e994bd2840d61f6dacea49e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/b0f289f02a4b4a63ab5fb6b255a1ea5b.png
[2cd88103cea545fa96d525bdaf5f8d4f.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/4c458a13c1364233abcc9b71588cd1d9.png
[c5b67d91a960406f986ae3590796e871.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/2fc1e874acfc408e8caa7be8bf85434c.png
[bcda813273a744a0966413f0b4aaf426.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/91120efea192472ea1ce3f8d20510cdc.png
[1496aa4950774fa1855e588d17005b72.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/5ff1d709c337427ab41077b39d512cc4.png
[a703c1c630714851a6d736244d99ac23.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/0465a87a14e9499eb7f226576d7d1a70.png
[31f607fb66e8451b8d7c8134e4193b20.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/081d88ae4dfe40fe9bf131683e771c61.png
[57db5fabf6814b7aa15fc3c9e616aec7.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/e1a9d93001b442a09edae4d85fb48b89.png
[3ab577761c094ce89e51a05641e9d6c9.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/31df69f193af4a2886d95a7bedb6c1ef.png
[e59bfc3711334226bd0bb9f9f50e0d6d.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/9b0fdd34ee924e309bb8bde816d409ee.png
[9c00ff5f4a0c49acb36ca89f97e5a022.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/a54a98aacb8f4fb49047f3cb367667a4.png
[6066aba594d646a58cfae3a65a7a4425.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/a35a5c07d194438cb9671b372bbc6d4c.png
[eddf566794624a5dbfde1e0acd38cefd.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/75b70383c79a4251a0aa24608dd47148.png