JAVA面试八股文之线程中的并发锁

柔光的暖阳◎ 2024-04-29 19:16 50阅读 0赞

#### 线程中并发锁 ####

*  讲一下synchronized关键字的底层原理？
 *   *  1.1 基本使用
     *  1.2 Monitor
 *  synchronized关键字的底层原理-进阶
 *   *  2.1 对象的内存结构
     *  2.2 MarkWord
     *  2.3 再说Monitor重量级锁
     *  2.4 轻量级锁
     *  2.5 偏向锁
     *  2.6 参考回答
 *  你谈谈 JMM（Java 内存模型）
 *  CAS 你知道吗？
 *   *  4.1 概述及基本工作流程
     *  4.2 CAS 底层实现
     *  4.3 乐观锁和悲观锁
 *  请谈谈你对 volatile 的理解
 *   *  5.1 保证线程间的可见性
     *  5.2 禁止进行指令重排序
 *  什么是AQS？
 *   *  6.1 概述
     *  6.2 工作机制
 *  ReentrantLock的实现原理
 *   *  7.1 概述
     *  7.2 实现原理
 *  synchronized和Lock有什么区别 ?
 *  死锁产生的条件是什么？
 *  如何进行死锁诊断？
 *  ConcurrentHashMap
 *   *  （1） JDK1.7中concurrentHashMap
     *  （2） JDK1.8中concurrentHashMap
 *  导致并发程序出现问题的根本原因是什么
 *   *  （1）原子性
     *  （2）内存可见性
     *  （3）有序性

## 讲一下synchronized关键字的底层原理？ ##

> 难易程度：☆☆☆☆☆
> 
> 出现频率：☆☆☆

### 1.1 基本使用 ###

如下抢票的代码，如果不加锁，就会出现超卖或者一张票卖给多个人

Synchronized【对象锁】采用互斥的方式让同一时刻至多只有一个线程能持有【对象锁】，其它线程再想获取这个【对象锁】时就会阻塞住。

public class TicketDemo {
        
    
        static Object lock = new Object();
        int ticketNum = 10;
    
    
        public synchronized void getTicket() {
        
            synchronized (this) {
        
                if (ticketNum <= 0) {
        
                    return;
                }
                System.out.println(Thread.currentThread().getName() + "抢到一张票,剩余:" + ticketNum);
                // 非原子性操作
                ticketNum--;
            }
        }
    
        public static void main(String[] args) {
        
            TicketDemo ticketDemo = new TicketDemo();
            for (int i = 0; i < 20; i++) {
        
                new Thread(() -> {
        
                    ticketDemo.getTicket();
                }).start();
            }
        }
    
    
    }

### 1.2 Monitor ###

Monitor 被翻译为监视器，是由jvm提供，c++语言实现

在代码中想要体现monitor需要借助javap命令查看clsss的字节码，比如以下代码：

public class SyncTest {
        
    
        static final Object lock = new Object();
        static int counter = 0;
        public static void main(String[] args) {
        
            synchronized (lock) {
        
                counter++;
            }
        }
    }

找到这个类的class文件，在class文件目录下执行`javap -v SyncTest.class`，反编译效果如下：  
![在这里插入图片描述][6b2f55286a984715b6c5cd53c985f864.png]

>  *  monitorenter 上锁开始的地方
>  *  monitorexit 解锁的地方
>  *  其中被monitorenter和monitorexit包围住的指令就是上锁的代码
>  *  有两个monitorexit的原因，第二个monitorexit是为了防止锁住的代码抛异常后不能及时释放锁

在使用了synchornized代码块时需要指定一个对象，所以synchornized也被称为对象锁

monitor主要就是跟这个对象产生关联，如下图  
![在这里插入图片描述][cd77d89ea4844f718d81a2fe372a12ee.png]  
Monitor内部具体的存储结构：

*  Owner：存储当前获取锁的线程的，只能有一个线程可以获取
 *  EntryList：关联没有抢到锁的线程，处于Blocked状态的线程
 *  WaitSet：关联调用了wait方法的线程，处于Waiting状态的线程

具体的流程：

*  代码进入synchorized代码块，先让lock（对象锁）关联的monitor，然后判断Owner是否有线程持有
 *  如果没有线程持有，则让当前线程持有，表示该线程获取锁成功
 *  如果有线程持有，则让当前线程进入entryList进行阻塞，如果Owner持有的线程已经释放了锁，在EntryList中的线程去竞争锁的持有权（非公平）
 *  如果代码块中调用了wait()方法，则会进去WaitSet中进行等待

参考回答：

*  Synchronized【对象锁】采用互斥的方式让同一时刻至多只有一个线程能持有【对象锁】
 *  它的底层由monitor实现的，monitor是jvm级别的对象（ C++实现），线程获得锁需要使用对象（锁）关联monitor
 *  在monitor内部有三个属性，分别是owner、entrylist、waitset
 *  其中owner是关联的获得锁的线程，并且只能关联一个线程；entrylist关联的是处于阻塞状态的线程；waitset关联的是处于Waiting状态的线程

## synchronized关键字的底层原理-进阶 ##

Monitor实现的锁属于重量级锁，你了解过锁升级吗？

*  Monitor实现的锁属于重量级锁，里面涉及到了用户态和内核态的切换、进程的上下文切换，成本较高，性能比较低。
 *  在JDK 1.6引入了两种新型锁机制：偏向锁和轻量级锁，它们的引入是为了解决在没有多线程竞争或基本没有竞争的场景下因使用传统锁机制带来的性能开销问题。

### 2.1 对象的内存结构 ###

在HotSpot虚拟机中，对象在内存中存储的布局可分为3块区域：对象头（Header）、实例数据（Instance Data）和对齐填充  
![在这里插入图片描述][72832a3dc3834ae1b271411cb438758b.png]

我们需要重点分析MarkWord对象头

### 2.2 MarkWord ###

![在这里插入图片描述][b1f231ec905b41aeb307d35d0f31c362.png]

>  *  hashcode：25位的对象标识Hash码
>  *  age：对象分代年龄占4位
>  *  biased\_lock：偏向锁标识，占1位 ，0表示没有开始偏向锁，1表示开启了偏向锁
>  *  thread：持有偏向锁的线程ID，占23位
>  *  epoch：偏向时间戳，占2位
>  *  ptr\_to\_lock\_record：轻量级锁状态下，指向栈中锁记录的指针，占30位
>  *  ptr\_to\_heavyweight\_monitor：重量级锁状态下，指向对象监视器Monitor的指针，占30位

我们可以通过lock的标识，来判断是哪一种锁的等级

*  后三位是001表示无锁
 *  后三位是101表示偏向锁
 *  后两位是00表示轻量级锁
 *  后两位是10表示重量级锁

### 2.3 再说Monitor重量级锁 ###

每个 Java 对象都可以关联一个 Monitor 对象，如果使用 synchronized 给对象上锁（重量级）之后，**该对象头的Mark Word 中就被设置指向 Monitor 对象的指针**  
![在这里插入图片描述][29cc3903ec4e41e4a23d614151accfd3.png]

简单说就是：每个对象的对象头都可以设置monoitor的指针，让对象与monitor产生关联

### 2.4 轻量级锁 ###

在很多的情况下，在Java程序运行时，同步块中的代码都是不存在竞争的，不同的线程交替的执行同步块中的代码。这种情况下，用重量级锁是没必要的。因此JVM引入了轻量级锁的概念。

static final Object obj = new Object();
    
    public static void method1() {
        
        synchronized (obj) {
        
            // 同步块 A
            method2();
        }
    }
    
    public static void method2() {
        
        synchronized (obj) {
        
            // 同步块 B
        }
    }

**加锁的流程**

1.在线程栈中创建一个Lock Record，将其obj字段指向锁对象。  
![在这里插入图片描述][9f91c09d42144d028d5bc1fcfad90029.png]

2.通过CAS指令将Lock Record的地址存储在对象头的mark word中（数据进行交换），如果对象处于无锁状态则修改成功，代表该线程获得了轻量级锁。  
![在这里插入图片描述][f927044ff1634754b3ac49e67e6a1bd1.png]

3.如果是当前线程已经持有该锁了，代表这是一次锁重入。设置Lock Record第一部分为null，起到了一个重入计数器的作用。  
![在这里插入图片描述][bb126e7d72fd4ce7bc122b279b1bb503.png]

4.如果CAS修改失败，说明发生了竞争，需要膨胀为重量级锁。

**解锁过程**

1.遍历线程栈,找到所有obj字段等于当前锁对象的Lock Record。

2.如果Lock Record的Mark Word为null，代表这是一次重入，将obj设置为null后continue。  
![在这里插入图片描述][726718f478ba4e93bd384714f24de5e4.png]  
3.如果Lock Record的 Mark Word不为null，则利用CAS指令将对象头的mark word恢复成为无锁状态。如果失败则膨胀为重量级锁。  
![在这里插入图片描述][33a5ed48fed846a696eda5b741cd1329.png]

### 2.5 偏向锁 ###

轻量级锁在没有竞争时（就自己这个线程），每次重入仍然需要执行 CAS 操作。

Java 6 中引入了偏向锁来做进一步优化：只有第一次使用 CAS 将线程 ID 设置到对象的 Mark Word 头，之后发现

这个线程 ID 是自己的就表示没有竞争，不用重新 CAS。以后只要不发生竞争，这个对象就归该线程所有

static final Object obj = new Object();
    
    public static void m1() {
        
        synchronized (obj) {
        
            // 同步块 A
            m2();
        }
    }
    
    public static void m2() {
        
        synchronized (obj) {
        
            // 同步块 B
            m3();
        }
    }
    
    public static void m3() {
        
        synchronized (obj) {
        
    
        }
    }

**加锁的流程**

1.在线程栈中创建一个Lock Record，将其obj字段指向锁对象。

![在这里插入图片描述][7adbf3a2c30c4b2fbfbbdca978afbe40.png]

2.通过CAS指令将Lock Record的**线程id**存储在对象头的mark word中，同时也设置偏向锁的标识为101，如果对象处于无锁状态则修改成功，代表该线程获得了偏向锁。  
![在这里插入图片描述][7975f079c1094f35bbd2eaf4e84147ad.png]

3.如果是当前线程已经持有该锁了，代表这是一次锁重入。设置Lock Record第一部分为null，起到了一个重入计数器的作用。与轻量级锁不同的时，这里不会再次进行cas操作，只是判断对象头中的线程id是否是自己，因为缺少了cas操作，性能相对轻量级锁更好一些  
![在这里插入图片描述][c41952f59b764a7d968e08953e034330.png]

解锁流程参考轻量级锁

### 2.6 参考回答 ###

Java中的synchronized有偏向锁、轻量级锁、重量级锁三种形式，分别对应了锁只被一个线程持有、不同线程交替持有锁、多线程竞争锁三种情况。

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th><strong>描述</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>重量级锁</td> 
   <td>底层使用的Monitor实现，里面涉及到了用户态和内核态的切换、进程的上下文切换，成本较高，性能比较低。</td> 
  </tr> 
  <tr> 
   <td>轻量级锁</td> 
   <td>线程加锁的时间是错开的（也就是没有竞争），可以使用轻量级锁来优化。轻量级修改了对象头的锁标志，相对重量级锁性能提升很多。每次修改都是CAS操作，保证原子性</td> 
  </tr> 
  <tr> 
   <td>偏向锁</td> 
   <td>一段很长的时间内都只被一个线程使用锁，可以使用了偏向锁，在第一次获得锁时，会有一个CAS操作，之后该线程再获取锁，只需要判断mark word中是否是自己的线程id即可，而不是开销相对较大的CAS命令</td> 
  </tr> 
 </tbody> 
</table>

**一旦锁发生了竞争，都会升级为重量级锁**

## 你谈谈 JMM（Java 内存模型） ##

> 难易程度：☆☆☆
> 
> 出现频率：☆☆☆

JMM(Java Memory Model)Java内存模型,是java虚拟机规范中所定义的一种内存模型。

Java内存模型(Java Memory Model)描述了Java程序中各种变量(线程共享变量)的访问规则，以及在JVM中将变量存储到内存和从内存中读取变量这样的底层细节。

![在这里插入图片描述][8e963ed02ad749fe851afaac457de494.png]

特点：

1.  所有的共享变量都存储于主内存(计算机的RAM)这里所说的变量指的是实例变量和类变量。不包含局部变量，因为局部变量是线程私有的，因此不存在竞争问题。
2.  每一个线程还存在自己的工作内存，线程的工作内存，保留了被线程使用的变量的工作副本。
3.  线程对变量的所有的操作(读，写)都必须在工作内存中完成，而不能直接读写主内存中的变量，不同线程之间也不能直接访问对方工作内存中的变量，线程间变量的值的传递需要通过主内存完成。

## CAS 你知道吗？ ##

> 难易程度：☆☆☆
> 
> 出现频率：☆☆

### 4.1 概述及基本工作流程 ###

CAS的全称是： Compare And Swap(比较再交换)，它体现的一种乐观锁的思想，在无锁情况下保证线程操作共享数据的原子性。

在JUC（ java.util.concurrent ）包下实现的很多类都用到了CAS操作

*  AbstractQueuedSynchronizer（AQS框架）
 *  AtomicXXX类

例子：

*  线程1与线程2都从主内存中获取变量int a = 100,同时放到各个线程的工作内存中

![在这里插入图片描述][dbb21d233baa43c7b216df9017c7c019.png]

> 一个当前内存值V、旧的预期值A、即将更新的值B，当且仅当旧的预期值A和内存值V相同时，将内存值修改为B并返回true，否则什么都不做，并返回false。如果CAS操作失败，通过自旋的方式等待并再次尝试，直到成功

*  线程1操作：V：int a = 100，A：int a = 100，B：修改后的值：int a = 101 (a++)
    
     *  线程1拿A的值与主内存V的值进行比较，判断是否相等
     *  如果相等，则把B的值101更新到主内存中  
        ![在这里插入图片描述][0bc1dad02afb4a1b94305d3d9442990f.png]
 *  线程2操作：V：int a = 100，A：int a = 100，B：修改后的值：int a = 99(a–)
    
     *  线程2拿A的值与主内存V的值进行比较，判断是否相等(目前不相等，因为线程1已更新V的值99)
     *  不相等，则线程2更新失败  
        ![在这里插入图片描述][3e7ad52101094453a42a6fbf96f59b4d.png]
 *  自旋锁操作
    
     *  因为没有加锁，所以线程不会陷入阻塞，效率较高
     *  如果竞争激烈，重试频繁发生，效率会受影响![在这里插入图片描述][1e14439d3e2749aabc0e908ab68427d7.png]

需要不断尝试获取共享内存V中最新的值，然后再在新的值的基础上进行更新操作，如果失败就继续尝试获取新的值，直到更新成功

### 4.2 CAS 底层实现 ###

CAS 底层依赖于一个 Unsafe 类来直接调用操作系统底层的 CAS 指令

![在这里插入图片描述][12b6e8dc0cff41c4b38745e98dfc5c84.png]

都是native修饰的方法，由系统提供的接口执行，并非java代码实现，一般的思路也都是自旋锁实现。

在java中比较常见使用有很多，比如ReentrantLock和Atomic开头的线程安全类，都调用了Unsafe中的方法

*  ReentrantLock中的一段CAS代码

![在这里插入图片描述][3a6b93c7213042649df991f69d730ad1.png]

### 4.3 乐观锁和悲观锁 ###

*  CAS 是基于乐观锁的思想：最乐观的估计，不怕别的线程来修改共享变量，就算改了也没关系，我吃亏点再重试呗。
 *  synchronized 是基于悲观锁的思想：最悲观的估计，得防着其它线程来修改共享变量，我上了锁你们都别想改，我改完了解开锁，你们才有机会。

## 请谈谈你对 volatile 的理解 ##

> 难易程度：☆☆☆
> 
> 出现频率：☆☆☆

一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

### 5.1 保证线程间的可见性 ###

保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的,volatile关键字会强制将修改的值立即写入主存。

一个典型的例子：永不停止的循环

package com.itheima.basic;
    
    
    // 可见性例子
    // -Xint
    public class ForeverLoop {
        
        static boolean stop = false;
    
        public static void main(String[] args) {
        
            new Thread(() -> {
        
                try {
        
                    Thread.sleep(100);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                stop = true;
                System.out.println("modify stop to true...");
            }).start();
            foo();
        }
    
        static void foo() {
        
            int i = 0;
            while (!stop) {
        
                i++;
            }
            System.out.println("stopped... c:"+ i);
        }
    }

当执行上述代码的时候，发现foo()方法中的循环是结束不了的，也就说读取不到共享变量的值结束循环。

主要是因为在JVM虚拟机中有一个JIT（即时编辑器）给代码做了优化。

> 上述代码
> 
>     while (!stop) {
>          
>     i++;
>     }
> 
> 在很短的时间内，这个代码执行的次数太多了，当达到了一个阈值，JIT就会优化此代码，如下：
> 
>     while (true) {
>          
>     i++;
>     }
> 
> 当把代码优化成这样子以后，及时`stop`变量改变为了`false`也依然停止不了循环

解决方案：

第一：

在程序运行的时候加入vm参数`-Xint`表示禁用即时编辑器，不推荐，得不偿失（其他程序还要使用）

第二：

在修饰`stop`变量的时候加上`volatile`,表示当前代码禁用了即时编辑器，问题就可以解决，代码如下：

static volatile boolean stop = false;

### 5.2 禁止进行指令重排序 ###

用 volatile 修饰共享变量会在读、写共享变量时加入不同的屏障，阻止其他读写操作越过屏障，从而达到阻止重排序的效果  
![在这里插入图片描述][d8ace262fb324d26aef24f4c0e89eb8c.png]

在去获取上面的结果的时候，有可能会出现4种情况

情况一：先执行actor2获取结果—>0,0(正常)

情况二：先执行actor1中的第一行代码，然后执行actor2获取结果—>0,1(正常)

情况三：先执行actor1中所有代码，然后执行actor2获取结果—>1,1(正常)

情况四：先执行actor1中第二行代码，然后执行actor2获取结果—>1,0(发生了指令重排序，影响结果)

**解决方案**

在变量上添加volatile，禁止指令重排序，则可以解决问题  
![在这里插入图片描述][18306ca9b8f94ff3bd6b3ca67fdc4710.png]

屏障添加的示意图  
![在这里插入图片描述][a7be3f8322564facb1121c0382baefb3.png]

*  写操作加的屏障是阻止上方其它写操作越过屏障排到volatile变量写之下
 *  读操作加的屏障是阻止下方其它读操作越过屏障排到volatile变量读之上

**其他补充**

我们上面的解决方案是把volatile加在了int y这个变量上，我们能不能把它加在int x这个变量上呢？

下面代码使用volatile修饰了x变量

![在这里插入图片描述][e7b4ec391cd1447bb5d51da73899ced9.png]

屏障添加的示意图

![在这里插入图片描述][e9776e76dd1a47a183bf2aa0f6ef46f3.png]

这样显然是不行的，主要是因为下面两个原则：

*  写操作加的屏障是阻止上方其它写操作越过屏障排到volatile变量写之下
 *  读操作加的屏障是阻止下方其它读操作越过屏障排到volatile变量读之上

所以，现在我们就可以总结一个volatile使用的小妙招：

*  写变量让volatile修饰的变量的在代码最后位置
 *  读变量让volatile修饰的变量的在代码最开始位置

## 什么是AQS？ ##

> 难易程度：☆☆☆
> 
> 出现频率：☆☆☆

### 6.1 概述 ###

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

AQS与Synchronized的区别

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

AQS常见的实现类

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

### 6.2 工作机制 ###

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

![在这里插入图片描述][ad5634d73af94e6ebadca09fcd3496dd.png]

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

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

![在这里插入图片描述][e5e959799c254057a66124414d6d856b.png]

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

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

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

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

## ReentrantLock的实现原理 ##

> 难易程度：☆☆☆☆
> 
> 出现频率：☆☆☆

### 7.1 概述 ###

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

*  可中断
 *  可以设置超时时间
 *  可以设置公平锁
 *  支持多个条件变量
 *  与synchronized一样，都支持重入  
    ![在这里插入图片描述][e262708ffdf34198bf23c5413d000048.png]

### 7.2 实现原理 ###

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

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

查看ReentrantLock源码中的构造方法：  
![在这里插入图片描述][2963dae2e0cd45289ecec21922457d92.png]

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

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

其中NonfairSync和FairSync这两个类父类都是Sync  
![在这里插入图片描述][b00526a4ddbc4b52ae93f8602f6f8e82.png]

而Sync的父类是AQS，所以可以得出ReentrantLock底层主要实现就是基于AQS来实现的  
![在这里插入图片描述][03db848e993541e68e801c29d981a67c.png]

**工作流程**  
![在这里插入图片描述][c7190e4bb1f54fb9917ee58e8c6201e7.png]

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

## synchronized和Lock有什么区别 ? ##

> 难易程度：☆☆☆☆
> 
> 出现频率：☆☆☆☆

参考回答

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

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

> 难易程度：☆☆☆☆
> 
> 出现频率：☆☆☆

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

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

代码如下：

package com.itheima.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();
        }
    }

控制台输出结果  
![在这里插入图片描述][e8cc25c55b954699b458dbebc6943698.png]

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

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

> 难易程度：☆☆☆
> 
> 出现频率：☆☆☆

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

步骤如下：

第一：查看运行的线程  
![在这里插入图片描述][f1cf0fc698d147c5b285a3314abd4b20.png]

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

运行命令：`jstack -l 46032`  
![在这里插入图片描述][18de43a99ea6463ebcd4531c1694686c.png]

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

*  jconsole

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

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

*  VisualVM：故障处理工具

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

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

## ConcurrentHashMap ##

> 难易程度：☆☆☆
> 
> 出现频率：☆☆☆☆

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

底层数据结构：

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

### （1） JDK1.7中concurrentHashMap ###

数据结构  
![在这里插入图片描述][4d6845e36cec4a838b2974f1fee2dcbf.png]

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

存储流程  
![在这里插入图片描述][4cc0e0a7ccfc46a2b7308c07d684a96a.png]

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

### （2） JDK1.8中concurrentHashMap ###

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

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

*  CAS控制数组节点的添加
 *  synchronized只锁定当前链表或红黑二叉树的首节点，只要hash不冲突，就不会产生并发的问题 , 效率得到提升  
    ![在这里插入图片描述][94eac56a734744ebaea20a37d05aa812.png]

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

> 难易程度：☆☆☆
> 
> 出现频率：☆☆☆

Java并发编程三大特性

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

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

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

比如，如下代码能保证原子性吗？  
![73ad8bf8d272404f86421c37a11b6374.png][]

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

解决方案：

1.synchronized：同步加锁

2.JUC里面的lock：加锁  
![在这里插入图片描述][4f38324e5f074c8192e714240e5e2fa4.png]

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

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

比如，以下代码不能保证内存可见性  
![在这里插入图片描述][69f4e017624841f2bbb85b31bd71842d.png]

解决方案：

*  synchronized
 *  volatile（推荐）
 *  LOCK

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

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

还是之前的例子，如下代码：  
![d7d0f04232ce46b9b78b4b6c0ac9c232.png][]  
解决方案：

*  volatile

**后记  
????美好的一天，到此结束，下次继续努力！欲知后续，请看下回分解，写作不易，感谢大家的支持！！ ???**

[6b2f55286a984715b6c5cd53c985f864.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/486b9f4b8bcf41fa98e53b9c9d4c3289.png
[cd77d89ea4844f718d81a2fe372a12ee.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/5b90b46c9b614f5b9f36e57048a3905b.png
[72832a3dc3834ae1b271411cb438758b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/dbaa1cd0245c495a891ddff4ab58b12a.png
[b1f231ec905b41aeb307d35d0f31c362.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/317dc10c05f94055b23122f607c00422.png
[29cc3903ec4e41e4a23d614151accfd3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/81accc4bd8564dfcac8fa1411b5936f2.png
[9f91c09d42144d028d5bc1fcfad90029.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/f390c591c99a45409c1d3807aac7504e.png
[f927044ff1634754b3ac49e67e6a1bd1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/6a5e9273d487459cb5c36b357ccb682a.png
[bb126e7d72fd4ce7bc122b279b1bb503.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/a65995deabb14509b3c3d06e416c0557.png
[726718f478ba4e93bd384714f24de5e4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/d836d90765f4408f8358f7ce59a56ff3.png
[33a5ed48fed846a696eda5b741cd1329.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/58e9706bb20a4efaa6b18fa355aadb39.png
[7adbf3a2c30c4b2fbfbbdca978afbe40.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/b63a2aea67dc449588092cbe9204c58f.png
[7975f079c1094f35bbd2eaf4e84147ad.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/27cbd027f9c94562be196c2536cafd2a.png
[c41952f59b764a7d968e08953e034330.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/2cb3b02327d04f32963dcf0dcf4a127c.png
[8e963ed02ad749fe851afaac457de494.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/be419769a7794f3f89fd1f4bd3b24f9e.png
[dbb21d233baa43c7b216df9017c7c019.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/7ae5620c91c34ce8bd3270e5b9d1cbce.png
[0bc1dad02afb4a1b94305d3d9442990f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/5b0938e1121c4d239a40443608421151.png
[3e7ad52101094453a42a6fbf96f59b4d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/df9997fc553f42e9a85f83bb74e36ffe.png
[1e14439d3e2749aabc0e908ab68427d7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/e67217bcebda4037b19f543f3cc8952a.png
[12b6e8dc0cff41c4b38745e98dfc5c84.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/1c83a9f51a9843e7a559878b4d0364b4.png
[3a6b93c7213042649df991f69d730ad1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/54392d060cc34ec6b29221dbcee2b2cd.png
[d8ace262fb324d26aef24f4c0e89eb8c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/299c2c66f52c408ba57221430aa4d6ac.png
[18306ca9b8f94ff3bd6b3ca67fdc4710.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/7454c379f3dd4d58aed380a27479fd97.png
[a7be3f8322564facb1121c0382baefb3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/f593cd8583c4434b86b8b607cb33c093.png
[e7b4ec391cd1447bb5d51da73899ced9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/68d97401bf124907bd35361752779718.png
[e9776e76dd1a47a183bf2aa0f6ef46f3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/c4ab67596dcd4c13b380a6877807969a.png
[ad5634d73af94e6ebadca09fcd3496dd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/046c76f69c9e4876ad4ae8f7d03e19ce.png
[e5e959799c254057a66124414d6d856b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/f85b0bb09cf543e8bbf4470ce558784f.png
[e262708ffdf34198bf23c5413d000048.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/25c4e4d603ca40468f157541ec4bf6cc.png
[2963dae2e0cd45289ecec21922457d92.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/d66765ef6b1442948c52db7626ba592b.png
[b00526a4ddbc4b52ae93f8602f6f8e82.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/0795064475d04b3aa1c7ca9302f0d44e.png
[03db848e993541e68e801c29d981a67c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/60968c105f5a49a9b5d6a82c4f654456.png
[c7190e4bb1f54fb9917ee58e8c6201e7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/d1a537c72cbc4c78b0180f4cb5848a96.png
[e8cc25c55b954699b458dbebc6943698.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/920c5d30c4e740959e2cb68957866b62.png
[f1cf0fc698d147c5b285a3314abd4b20.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/5605355e30504c2a8771bf24cd474897.png
[18de43a99ea6463ebcd4531c1694686c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/6c52f0df8d01495eb953903347f64a88.png
[4d6845e36cec4a838b2974f1fee2dcbf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/136f1391663b4c85863d4774ab63a3ec.png
[4cc0e0a7ccfc46a2b7308c07d684a96a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/583159c007164de68ab810fd8044dcfb.png
[94eac56a734744ebaea20a37d05aa812.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/9d3187f14660485a88c3a420112e6962.png
[73ad8bf8d272404f86421c37a11b6374.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/f2a3bea17b9845bd93e2c785eaa09960.png
[4f38324e5f074c8192e714240e5e2fa4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/31efeced68454f9e97c4b88e8d4458ee.png
[69f4e017624841f2bbb85b31bd71842d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/2fca69a9b703454c85fe4cd800b8612b.png
[d7d0f04232ce46b9b78b4b6c0ac9c232.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/29/171e33ef46274d16b6f12cb7eb23c74c.png