Java面试知识点(全)- Java并发-多线程JUC二-原子类/锁

Java面试知识点(全)
导航： https://nanxiang.blog.csdn.net/article/details/130640392
注：随时更新

JUC原子类

什么是CAS

CAS的全称为Compare-And-Swap，直译就是对比交换。是一条CPU的原子指令，其作用是让CPU先进行比较两个值是否相等，然后原子地更新某个位置的值，经过调查发现，其实现方式是基于硬件平台的汇编指令，就是说CAS是靠硬件实现的，JVM只是封装了汇编调用，那些AtomicInteger类便是使用了这些封装后的接口。   简单解释：CAS操作需要输入两个数值，一个旧值(期望操作前的值)和一个新值，在操作期间先比较下在旧值有没有发生变化，如果没有发生变化，才交换成新值，发生了变化则不交换。
CAS操作是原子性的，所以多线程并发使用CAS更新数据时，可以不使用锁。JDK中大量使用了CAS来更新数据而防止加锁(synchronized 重量级锁)来保持原子更新。
相信sql大家都熟悉，类似sql中的条件更新一样：update set id=3 from table where id=2。因为单条sql执行具有原子性，如果有多个线程同时执行此sql语句，只有一条能更新成功。

CAS使用示例，结合AtomicInteger给出示例

如果不使用CAS，在高并发下，多线程同时修改一个变量的值我们需要synchronized加锁(可能有人说可以用Lock加锁，Lock底层的AQS也是基于CAS进行获取锁的)。

public class Test {private int i=0;public synchronized int add(){return i++;}
}

java中为我们提供了AtomicInteger 原子类(底层基于CAS进行更新数据的)，不需要加锁就在多线程并发场景下实现数据的一致性。
public class Test {private  AtomicInteger i = new AtomicInteger(0);public int add(){return i.addAndGet(1);}
}

CAS会有哪些问题

CAS 方式为乐观锁，synchronized 为悲观锁。因此使用 CAS 解决并发问题通常情况下性能更优。
但使用 CAS 方式也会有几个问题：
- ABA问题
因为CAS需要在操作值的时候，检查值有没有发生变化，比如没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时则会发现它的值没有发生变化，但是实际上却变化了。
ABA问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加1，那么A->B->A就会变成1A->2B->3A。
从Java 1.5开始，JDK的Atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法的作用是首先检查当前引用是否等于预期引用，并且检查当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。
- 循环时间长开销大
自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销。如果JVM能支持处理器提供的pause指令，那么效率会有一定的提升。pause指令有两个作用：第一，它可以延迟流水线执行命令(de-pipeline)，使CPU不会消耗过多的执行资源，延迟的时间取决于具体实现的版本，在一些处理器上延迟时间是零；第二，它可以避免在退出循环的时候因内存顺序冲突(Memory Order Violation)而引起CPU流水线被清空(CPU Pipeline Flush)，从而提高CPU的执行效率。
- 只能保证一个共享变量的原子操作
当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁。
还有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如，有两个共享变量i = 2，j = a，合并一下ij = 2a，然后用CAS来操作ij。
从Java 1.5开始，JDK提供了AtomicReference类来保证引用对象之间的原子性，就可以把多个变量放在一个对象里来进行CAS操作。

AtomicInteger底层实现

- CAS+volatile ,cas保证线程的原子性
- volatile保证线程的可见性，多线程并发时，一个线程修改数据，可以保证其它线程立马看到修改后的值CAS 保证数据更新的原子性。

Java原子类的理解

包含13个，4组分类，说说作用和使用场景。
• 原子更新基本类型
○ AtomicBoolean: 原子更新布尔类型。
○ AtomicInteger: 原子更新整型。
○ AtomicLong: 原子更新长整型。
• 原子更新数组
○ AtomicIntegerArray: 原子更新整型数组里的元素。
○ AtomicLongArray: 原子更新长整型数组里的元素。
○ AtomicReferenceArray: 原子更新引用类型数组里的元素。
• 原子更新引用类型
○ AtomicIntegerFieldUpdater: 原子更新整型的字段的更新器。
○ AtomicLongFieldUpdater: 原子更新长整型字段的更新器。
○ AtomicStampedFieldUpdater: 原子更新带有版本号的引用类型。
○ AtomicReferenceFieldUpdater: 上面已经说过此处不在赘述
• 原子更新字段类
○ AtomicReference: 原子更新引用类型。
○ AtomicStampedReference: 原子更新引用类型, 内部使用Pair来存储元素值及其版本号。
○ AtomicMarkableReferce: 原子更新带有标记位的引用类型。

AtomicStampedReference是怎么解决ABA的?

AtomicStampedReference主要维护包含一个对象引用以及一个可以自动更新的整数"stamp"的pair对象来解决ABA问题。

JUC锁

为什么LockSupport也是核心基础类

AQS框架借助于两个类：Unsafe(提供CAS操作)和LockSupport(提供park/unpark操作)

通过wait/notify实现同步

class MyThread extends Thread {public void run() {synchronized (this) {System.out.println("before notify");            notify();System.out.println("after notify");    }}
}
public class WaitAndNotifyDemo {public static void main(String[] args) throws InterruptedException {MyThread myThread = new MyThread();            synchronized (myThread) {try {        myThread.start();// 主线程睡眠3sThread.sleep(3000);System.out.println("before wait");// 阻塞主线程myThread.wait();System.out.println("after wait");} catch (InterruptedException e) {e.printStackTrace();}            }        }
}
运行结果
before wait
before notify
after notify
after wait

通过LockSupport的park/unpark实现同步

import java.util.concurrent.locks.LockSupport;
class MyThread extends Thread {private Object object;
public MyThread(Object object) {this.object = object;}
public void run() {System.out.println("before unpark");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}// 获取blockerSystem.out.println("Blocker info " + LockSupport.getBlocker((Thread) object));// 释放许可LockSupport.unpark((Thread) object);// 休眠500ms，保证先执行park中的setBlocker(t, null);try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}// 再次获取blockerSystem.out.println("Blocker info " + LockSupport.getBlocker((Thread) object));
System.out.println("after unpark");}
}
public class test {public static void main(String[] args) {MyThread myThread = new MyThread(Thread.currentThread());myThread.start();System.out.println("before park");// 获取许可LockSupport.park("ParkAndUnparkDemo");System.out.println("after park");}
}

运行结果:
before park
before unpark
Blocker info ParkAndUnparkDemo
after park
Blocker info null
after unpark
说明: 本程序先执行park，然后在执行unpark，进行同步，并且在unpark的前后都调用了getBlocker，可以看到两次的结果不一样，并且第二次调用的结果为null，这是因为在调用unpark之后，执行了Lock.park(Object blocker)函数中的setBlocker(t, null)函数，所以第二次调用getBlocker时为null。
上例是先调用park，然后调用unpark，现在修改程序，先调用unpark，然后调用park，看能不能正确同步。具体代码如下

import java.util.concurrent.locks.LockSupport;
class MyThread extends Thread {private Object object;
public MyThread(Object object) {this.object = object;}
public void run() {System.out.println("before unpark");        // 释放许可LockSupport.unpark((Thread) object);System.out.println("after unpark");}
}
public class ParkAndUnparkDemo {public static void main(String[] args) {MyThread myThread = new MyThread(Thread.currentThread());myThread.start();try {// 主线程睡眠3sThread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("before park");// 获取许可LockSupport.park("ParkAndUnparkDemo");System.out.println("after park");}
}

运行结果:
before unpark
after unpark
before park
after park
说明: 可以看到，在先调用unpark，再调用park时，仍能够正确实现同步，不会造成由wait/notify调用顺序不当所引起的阻塞。因此park/unpark相比wait/notify更加的灵活。

Thread.sleep()、Object.wait()、Condition.await()、LockSupport.park()的区别

• Thread.sleep()和Object.wait()的区别

首先，我们先来看看Thread.sleep()和Object.wait()的区别，这是一个烂大街的题目了，大家应该都能说上来两点。
1. Thread.sleep()不会释放占有的锁，Object.wait()会释放占有的锁；
2. Thread.sleep()必须传入时间，Object.wait()可传可不传，不传表示一直阻塞下去；
3. Thread.sleep()到时间了会自动唤醒，然后继续执行；
4. Object.wait()不带时间的，需要另一个线程使用Object.notify()唤醒；
5. Object.wait()带时间的，假如没有被notify，到时间了会自动唤醒，这时又分好两种情况，一是立即获取到了锁，线程自然会继续执行；二是没有立即获取锁，线程进入同步队列等待获取锁；
其实，他们俩最大的区别就是Thread.sleep()不会释放锁资源，Object.wait()会释放锁资源。
• Object.wait()和Condition.await()的区别
Object.wait()和Condition.await()的原理是基本一致的，不同的是Condition.await()底层是调用LockSupport.park()来实现阻塞当前线程的。
实际上，它在阻塞当前线程之前还干了两件事，一是把当前线程添加到条件队列中，二是“完全”释放锁，也就是让state状态变量变为0，然后才是调用LockSupport.park()阻塞当前线程。
• Thread.sleep()和LockSupport.park()的区别 LockSupport.park()还有几个兄弟方法——parkNanos()、parkUtil()等，我们这里说的park()方法统称这一类方法。
1. 从功能上来说，Thread.sleep()和LockSupport.park()方法类似，都是阻塞当前线程的执行，且都不会释放当前线程占有的锁资源；
2. Thread.sleep()没法从外部唤醒，只能自己醒过来；
3. LockSupport.park()方法可以被另一个线程调用LockSupport.unpark()方法唤醒；
4. Thread.sleep()方法声明上抛出了InterruptedException中断异常，所以调用者需要捕获这个异常或者再抛出；
5. LockSupport.park()方法不需要捕获中断异常；
6. Thread.sleep()本身就是一个native方法；
7. LockSupport.park()底层是调用的Unsafe的native方法；
• Object.wait()和LockSupport.park()的区别
二者都会阻塞当前线程的运行，他们有什么区别呢? 经过上面的分析相信你一定很清楚了，真的吗? 往下看！
1. Object.wait()方法需要在synchronized块中执行；
2. LockSupport.park()可以在任意地方执行；
3. Object.wait()方法声明抛出了中断异常，调用者需要捕获或者再抛出；
4. LockSupport.park()不需要捕获中断异常；
5. Object.wait()不带超时的，需要另一个线程执行notify()来唤醒，但不一定继续执行后续内容；
6. LockSupport.park()不带超时的，需要另一个线程执行unpark()来唤醒，一定会继续执行后续内容；
park()/unpark()底层的原理是“二元信号量”，你可以把它相像成只有一个许可证的Semaphore，只不过这个信号量在重复执行unpark()的时候也不会再增加许可证，最多只有一个许可证。

如果在wait()之前执行了notify()会怎样

如果当前的线程不是此对象锁的所有者，却调用该对象的notify()或wait()方法时抛出IllegalMonitorStateException异常；
如果当前线程是此对象锁的所有者，wait()将一直阻塞，因为后续将没有其它notify()唤醒它。

如果在park()之前执行了unpark()会怎样

线程不会被阻塞，直接跳过park()，继续执行后续内容

什么是AQS? 为什么它是核心?

AQS是一个用来构建锁和同步器的框架，使用AQS能简单且高效地构造出应用广泛的大量的同步器，比如我们提到的ReentrantLock，Semaphore，其他的诸如ReentrantReadWriteLock，SynchronousQueue，FutureTask等等皆是基于AQS的。
AQS核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。

AbstractQueuedSynchronizer类底层的数据结构是使用CLH(Craig,Landin,and Hagersten)队列是一个虚拟的双向队列(虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系)。AQS是将每条请求共享资源的线程封装成一个CLH锁队列的一个结点(Node)来实现锁的分配。其中Sync queue，即同步队列，是双向链表，包括head结点和tail结点，head结点主要用作后续的调度。而Condition queue不是必须的，其是一个单向链表，只有当使用Condition时，才会存在此单向链表。并且可能会有多个Condition queue。

AQS的核心思想

底层数据结构: AQS核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。

AQS有哪些核心的方法

isHeldExclusively()//该线程是否正在独占资源。只有用到condition才需要去实现它。
tryAcquire(int)//独占方式。尝试获取资源，成功则返回true，失败则返回false。
tryRelease(int)//独占方式。尝试释放资源，成功则返回true，失败则返回false。
tryAcquireShared(int)//共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
tryReleaseShared(int)//共享方式。尝试释放资源，成功则返回true，失败则返回false。

AQS定义什么样的资源获取方式

AQS定义了两种资源获取方式：
• 独占(只有一个线程能访问执行，又根据是否按队列的顺序分为公平锁和非公平锁，如ReentrantLock)
• 共享(多个线程可同时访问执行，如Semaphore、CountDownLatch、 CyclicBarrier )。ReentrantReadWriteLock可以看成是组合式，允许多个线程同时对某一资源进行读。

AQS底层使用了什么样的设计模式

模板， 共享锁和独占锁在一个接口类中。

Lock

什么是可重入，什么是可重入锁， 它用来解决什么问题

可重入：（来源于维基百科）若一个程序或子程序可以“在任意时刻被中断然后操作系统调度执行另外一段代码，这段代码又调用了该子程序不会出错”，则称其为可重入（reentrant或re-entrant）的。即当该子程序正在运行时，执行线程可以再次进入并执行它，仍然获得符合设计时预期的结果。与多线程并发执行的线程安全不同，可重入强调对单个线程执行时重新进入同一个子程序仍然是安全的。
可重入锁：又名递归锁，是指在同一个线程在外层方法获取锁的时候，再进入该线程的内层方法会自动获取锁（前提锁对象得是同一个对象或者class），不会因为之前已经获取过还没释放而阻塞。

ReentrantLock的核心是AQS，那么它怎么来实现的

ReentrantLock总共有三个内部类，并且三个内部类是紧密相关的，下面先看三个类的关系。

说明: ReentrantLock类内部总共存在Sync、NonfairSync、FairSync三个类，NonfairSync与FairSync类继承自Sync类，Sync类继承自AbstractQueuedSynchronizer抽象类。下面逐个进行分析。

ReentrantLock是如何实现公平锁的

FairSync

ReentrantLock是如何实现非公平锁的

UnFairSync

ReentrantLock默认实现的是公平还是非公平锁

非公平锁

为了有了ReentrantLock还需要ReentrantReadWriteLock

读锁和写锁分离：ReentrantReadWriteLock表示可重入读写锁，ReentrantReadWriteLock中包含了两种锁，读锁ReadLock和写锁WriteLock，可以通过这两种锁实现线程间的同步。

ReentrantReadWriteLock底层实现原理

ReentrantReadWriteLock有五个内部类，五个内部类之间也是相互关联的。内部类的关系如下图所示。

说明: 如上图所示，Sync继承自AQS、NonfairSync继承自Sync类、FairSync继承自Sync类；ReadLock实现了Lock接口、WriteLock也实现了Lock接口。

ReentrantReadWriteLock底层读写状态如何设计的

高16位为读锁，低16位为写锁

读锁和写锁的最大数量是多少

2的16次方-1

本地线程计数器ThreadLocalHoldCounter是用来做什么的

本地线程计数器，与对象绑定（线程-》线程重入的次数）

写锁的获取与释放是怎么实现的

tryAcquire/tryRelease

读锁的获取与释放是怎么实现的

tryAcquireShared/tryReleaseShared

什么是锁的升降级

RentrantReadWriteLock为什么不支持锁升级? RentrantReadWriteLock不支持锁升级(把持读锁、获取写锁，最后释放读锁的过程)。目的也是保证数据可见性，如果读锁已被多个线程获取，其中任意线程成功获取了写锁并更新了数据，则其更新对其他获取到读锁的线程是不可见的。

ReentrantReadWriteLock样例

/*** @author weidong* @version V1.0.0* @description* @since 2023/5/19*/
class ReadThread extends Thread {private ReentrantReadWriteLock rrwLock;public ReadThread(String name, ReentrantReadWriteLock rrwLock) {super(name);this.rrwLock = rrwLock;}public void run() {System.out.println(Thread.currentThread().getName() + " trying to lock");try {rrwLock.readLock().lock();System.out.println(Thread.currentThread().getName() + " lock successfully");Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();} finally {rrwLock.readLock().unlock();System.out.println(Thread.currentThread().getName() + " unlock successfully");}}
}class WriteThread extends Thread {private ReentrantReadWriteLock rrwLock;public WriteThread(String name, ReentrantReadWriteLock rrwLock) {super(name);this.rrwLock = rrwLock;}public void run() {System.out.println(Thread.currentThread().getName() + " trying to lock");try {rrwLock.writeLock().lock();System.out.println(Thread.currentThread().getName() + " lock successfully");} finally {rrwLock.writeLock().unlock();System.out.println(Thread.currentThread().getName() + " unlock successfully");}}
}public class ReentrantReadWriteLockDemo {public static void main(String[] args) {ReentrantReadWriteLock rrwLock = new ReentrantReadWriteLock();ReadThread rt1 = new ReadThread("rt1", rrwLock);ReadThread rt2 = new ReadThread("rt2", rrwLock);WriteThread wt1 = new WriteThread("wt1", rrwLock);rt1.start();rt2.start();wt1.start();}
}

参考文章：https://www.pdai.tech/md/interview/x-interview.html#_3-6-juc%E9%9B%86%E5%90%88%E7%B1%BB

外传

😜 原创不易，如若本文能够帮助到您的同学
🎉 支持我：关注我+点赞👍+收藏⭐️
📝 留言：探讨问题，看到立马回复
💬 格言：己所不欲勿施于人 扬帆起航、游历人生、永不言弃！🔥