关于java:阿里面试官首次分享完整版多线程核心题你准备好跳槽了吗

今日分享开始啦，请大家多多指教~

明天给大家分享的是比拟全面的多线程面试题，大家在面试的过程中未免会被问到很多专业性的问题，有的时候答复的并不是那么全面和精密，这仅仅代表个人观点。

1. 首先须要将死锁产生的是个必要条件讲进去:

互斥条件同一时间只能有一个线程获取资源。
不可剥夺条件一个线程曾经占有的资源，在开释之前不会被其它线程抢占
申请和放弃条件线程期待过程中不会开释已占有的资源
循环期待条件多个线程相互期待对方开释资源

2. 死锁预防，那么就是须要毁坏这四个必要条件：

因为资源互斥是资源应用的固有个性，无奈扭转，咱们不探讨
毁坏不可剥夺条件

一个过程不能取得所须要的全副资源时便处于期待状态，期待期间他占有的资源将被隐式地开释重新加入到零碎的资源列表中，能够被其余的过程应用，而期待的过程只有从新取得本人原有的资源以及新申请的资源才能够重新启动，执行

毁坏申请与放弃条件

第一种办法动态调配即每个过程在开始执行时就申请他所须要的全副资源,

第二种是动态分配即每个过程在申请所须要的资源时他自身不占用系统资源

毁坏循环期待条件

采纳资源有序调配其根本思维是将零碎中的所有资源程序编号，将紧缺的，稀少地采纳较大的编号，在申请资源时必须依照编号的程序进行，一个过程只有取得较小编号的过程能力申请较大编号的过程。

实现 Runnable，Runnable 规定的办法是 run()，无返回值，无奈抛出异样
实现 Callable，Callable 规定的办法是 call()，工作执行后有返回值，能够抛出异样
继承 Thread 类创立多线程：继承 java.lang.Thread 类，重写 Thread 类的 run()办法，在 run()办法中实现运行在线程上的代码，调用 start()办法开启线程。
Thread 类实质上是实现了 Runnable 接口的一个实例，代表一个线程的实例。启动线程的惟一办法就是通过 Thread 类的 start()实例办法。start()办法是一个 native 办法，它将启动一个新线程，并执行 run()办法
通过线程池创立线程. 线程和数据库连贯这些资源都是十分贵重的资源。那么每次须要的时候创立，不须要的时候销毁，是十分浪费资源的。那么咱们就能够应用缓存的策略，也就是应用线程池。

线程平安的活跃性问题能够分为死锁、活锁、饥饿

1. 活锁就是有时线程尽管没有产生阻塞，然而依然会存在执行不上来的状况，活锁不会阻塞线程，线程会始终反复执行某个雷同的操作，并且始终失败重试

咱们开发中应用的异步音讯队列就有可能造成活锁的问题，在音讯队列的生产端如果没有正确的 ack 音讯，并且执行过程中报错了，就会再次放回音讯头，而后再拿进去执行，始终周而复始的失败。这个问题除了正确的 ack 之外，往往是通过将失败的音讯放入到延时队列中，等到肯定的延时再进行重试来解决。
解决活锁的计划很简略，尝试期待一个随机的工夫就能够，会按工夫轮去重试

2. 饥饿就是线程因无法访问所需资源而无奈执行上来的状况，

饥饿分为两种状况：

一种是其余的线程在临界区做了有限循环或无限度期待资源的操作，让其余的线程始终不能拿到锁进入临界区，对其余线程来说，就进入了饥饿状态
另一种是因为线程优先级不合理的调配，导致局部线程始终无奈获取到 CPU 资源而始终无奈执行

3. 解决饥饿的问题有几种计划:

保障资源短缺，很多场景下，资源的稀缺性无奈解决
偏心分配资源，在并发编程里应用偏心锁，例如 FIFO 策略，线程期待是有程序的，排在期待队列后面的线程会优先取得资源
防止持有锁的线程长时间执行，很多场景下，持有锁的线程的执行工夫也很难缩短

4. 死锁线程在对同一把锁进行竞争的时候，未抢占到锁的线程会期待持有锁的线程开释锁后持续抢占，如果两个或两个以上的线程相互持有对方将要抢占的锁，相互期待对方后行开释锁就会进入到一个循环期待的过程，这个过程就叫做死锁

线程平安的竞态条件问题

同一个程序多线程拜访同一个资源，如果对资源的拜访程序敏感，就称存在竞态条件，代码区成为临界区。大多数并发谬误一样，竞态条件不总是会产生问题，还须要不失当的执行时序

最常见的竞态条件为

先检测后执行执行依赖于检测的后果，而检测后果依赖于多个线程的执行时序，而多个线程的执行时序通常状况下是不固定不可判断的，从而导致执行后果呈现各种问题，见一种可能的解决办法就是：在一个线程批改拜访一个状态时，要避免其余线程拜访批改，也就是加锁机制，保障原子性
提早初始化（典型为单例）

1. 所属类: 首先，这两个办法来自不同的类别离是 Thread 和 Object，wait 是 Object 的办法，sleep 是 Thread 的办法

sleep 办法属于 Thread 类中办法，示意让一个线程进入睡眠状态，期待肯定的工夫之后，主动醒来进入到可运行状态，不会马上进入运行状态，因为线程调度机制复原线程的运行也须要工夫，一个线程对象调用了 sleep 办法之后，并不会开释他所持有的所有对象锁，所以也就不会影响其余过程对象的运行。但在 sleep 的过程中过程中有可能被其余对象调用它的 interrupt(), 产生 InterruptedException 异样，如果你的程序不捕捉这个异样，线程就会异样终止，进入 TERMINATED 状态，如果你的程序捕捉了这个异样，那么程序就会继续执行 catch 语句块 (可能还有 finally 语句块) 以及当前的代码

2. 作用范畴: sleep 办法没有开释锁，只是休眠，而 wait 开释了锁，使得其余线程能够应用同步控制块或办法

3. 应用范畴: wait，notify 和 notifyAll 只能在同步控制办法或者同步控制块外面应用，而 sleep 能够在任何中央应用

4. 异样范畴：sleep 必须捕捉异样，而 wait，notify 和 notifyAll 不须要捕捉异样

1. 过程（Process）

是零碎进行资源分配和调度的根本单位，是操作系统构造的根底。在当代面向线程设计的计算机构造中，过程是线程的容器。程序是指令、数据及其组织模式的形容，过程是程序的实体。是计算机中的程序对于某数据汇合上的一次运行流动，是零碎进行资源分配和调度的根本单位，是操作系统构造的根底。程序是指令、数据及其组织模式的形容，过程是程序的实体。总结: j 过程是指在零碎中正在运行的一个应用程序；程序一旦运行就是过程；过程——资源分配的最小单位

2. 线程

操作系统可能进行运算调度的最小单位。它被蕴含在过程之中，是过程中的理论运作单位。一条线程指的是过程中一个繁多程序的控制流，一个过程中能够并发多个线程，每条线程并行执行不同的工作。总结: 零碎调配处理器工夫资源的根本单元，或者说过程之内独立执行的一个单元执行流。线程——程序执行的最小单位

大抵包含 5 个阶段

新建就是刚应用 new 办法，new 进去的线程；
就绪就是调用的线程的 start()办法后，这时候线程处于期待 CPU 分配资源阶段，谁先抢的 CPU 资源，谁开始执行;
运行当就绪的线程被调度并取得 CPU 资源时，便进入运行状态，run 办法定义了线程的操作和性能;
阻塞在运行状态的时候，可能因为某些起因导致运行状态的线程变成了阻塞状态，比方 sleep()、wait()之后线程就处于了阻塞状态，这个时候须要其余机制将处于阻塞状态的线程唤醒，比方调用 notify 或者 notifyAll()办法。唤醒的线程不会立即执行 run 办法，它们要再次期待 CPU 分配资源进入运行状态;
销毁如果线程失常执行结束后或线程被提前强制性的终止或出现异常导致完结，那么线程就要被销毁，开释资源

1. 按 JDK 的源码剖析来看，Thread 的状态分为：

NEW：尚未启动的线程的线程状态
RUNNABLE：处于可运行状态的线程正在 Java 虚拟机中执行，但它可能正在期待来自操作系统（例如处理器）的其余资源
BLOCKED：线程的线程状态被阻塞，期待监视器锁定。处于阻塞状态的线程正在期待监视器锁定以输出同步的块办法或在调用后从新输出同步的块办法，通过 Object#wait()进入阻塞
WAITING：处于期待状态的线程正在期待另一个线程执行特定操作：例如: 在对象上调用了 Object.wait（）的线程正在期待另一个线程调用 Object.notify（）或者 Object.notifyAll(), 调用了 Thread.join（）的线程正在期待指定的线程终止
TIMED_WAITING：具备指定等待时间的期待线程的线程状态。因为以指定的正等待时间调用以下办法之一，因而线程处于定时期待状态：
Thread.sleep（long）
Object#wait(long)
Thread.join（long）
LockSupport.parkNanos（long…）
LockSupport.parkUntil（long…）

2.TERMINATED: 终止线程的线程状态。线程已实现执行

1. 这里须要区别下利用是什么样的程序：

CPU 密集型程序，一个残缺申请，I/ O 操作能够在很短时间内实现，CPU 还有很多运算要解决，也就是说 CPU 计算的比例占很大一部分，线程等待时间靠近 0

单核 CPU：一个残缺申请，I/ O 操作能够在很短时间内实现，CPU 还有很多运算要解决，也就是说 CPU 计算的比例占很大一部分，线程等待时间靠近 0。单核 CPU 处理 CPU 密集型程序，这种状况并不太适宜应用多线程
多核：如果是多核 CPU 解决 CPU 密集型程序，咱们齐全能够最大化地利用 CPU 外围数，利用并发编程来提高效率。CPU 密集型程序的最佳线程数就是：因而对于 CPU 密集型来说，实践上线程数量 = CPU 核数（逻辑），然而实际上，数量个别会设置为 CPU 核数（逻辑）+ 1（经验值）计算 (CPU) 密集型的线程恰好在某时因为产生一个页谬误或者因其余起因而暂停，刚好有一个“额定”的线程，能够确保在这种状况下 CPU 周期不会中断工作

2.I/O 密集型程序，与 CPU 密集型程序绝对，一个残缺申请，CPU 运算操作实现之后还有很多 I/O 操作要做，也就是说 I/O 操作占比很大部分，等待时间较长，线程等待时间所占比例越高，须要越多线程；线程 CPU 工夫所占比例越高，须要越少线程

I/O 密集型程序的最佳线程数就是：最佳线程数 = CPU 外围数 (1/CPU 利用率) =CPU 外围数 (1 + (I/ O 耗时 /CPU 耗时))
如果简直全是 I/ O 耗时，那么 CPU 耗时就有限趋近于 0，所以纯理论你就能够说是 2N（N=CPU 核数），当然也有说 2N + 1 的，1 应该是 backup
个别咱们说 2N + 1 就即可

1. 首先最好说一下锁池和期待池的概念

锁池: 假如线程 A 曾经领有了某个对象 (留神: 不是类) 的锁，而其它的线程想要调用这个对象的某个 synchronized 办法(或者 synchronized 块)，因为这些线程在进入对象的 synchronized 办法之前必须先取得该对象的锁的拥有权，然而该对象的锁目前正被线程 A 领有，所以这些线程就进入了该对象的锁池中。
期待池: 假如一个线程 A 调用了某个对象的 wait()办法，线程 A 就会开释该对象的锁 (因为 wait() 办法必须呈现在 synchronized 中，这样天然在执行 wait()办法之前线程 A 就曾经领有了该对象的锁)，同时线程 A 就进入到了该对象的期待池中。如果另外的一个线程调用了雷同对象的 notifyAll()办法，那么处于该对象的期待池中的线程就会全副进入该对象的锁池中，筹备抢夺锁的拥有权。如果另外的一个线程调用了雷同对象的 notify()办法，那么仅仅有一个处于该对象的期待池中的线程 (随机) 会进入该对象的锁池.

2. 如果线程调用了对象的 wait()办法，那么线程便会处于该对象的期待池中，期待池中的线程不会去竞争该对象的锁

3. 当有线程调用了对象的 notifyAll()办法（唤醒所有 wait 线程）或 notify()办法（只随机唤醒一个 wait 线程），被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会去竞争该对象锁。也就是说，调用了 notify 后只有一个线程会由期待池进入锁池，而 otifyAll 会将该对象期待池内的所有线程挪动到锁池中，期待锁竞争

4. 所谓唤醒线程，另一种解释能够说是将线程由期待池挪动到锁池，notifyAll 调用后，会将全副线程由期待池移到锁池，而后参加锁的竞争，竞争胜利则继续执行，如果不胜利则留在锁池期待锁被开释后再次参加竞争。而 notify 只会唤醒一个线程。

如下表

能够再多说下 synchronized 的加锁流程

因为 HotSpot 的作者通过钻研发现，大多数状况下，锁不仅不存在多线程竞争，而且总是由同一线程屡次取得，为了让线程取得锁的代价更低从而引入偏差锁。偏差锁在获取资源的时候会在锁对象头上记录以后线程 ID，偏差锁并不会被动开释，这样每次偏差锁进入的时候都会判断锁对象头中线程 ID 是否为本人，如果是以后线程重入，间接进入同步操作，不须要额定的操作。默认在开启偏差锁和轻量锁的状况下，当线程进来时，首先会加上偏差锁，其实这里只是用一个状态来管制，会记录加锁的线程，如果是线程重入，则不会进行锁降级。获取偏差锁

流程：

判断是否为可偏差状态 –MarkWord 中锁标记是否为‘01’，是否偏差锁是否为‘1’
如果是可偏差状态，则查看线程 ID 是否为以后线程，如果是，则进入步骤 ‘V’，否则进入步骤‘III’
通过 CAS 操作竞争锁，如果竞争胜利，则将 MarkWord 中线程 ID 设置为以后线程 ID，而后执行‘V’；竞争失败，则执行‘IV’
CAS 获取偏差锁失败示意有竞争。当达到 safepoint 时取得偏差锁的线程被挂起，偏差锁降级为轻量级锁，而后被阻塞在平安点的线程持续往下执行同步代码块
执行同步代码

轻量级锁是绝对于重量级锁须要阻塞 / 唤醒波及上下文切换而言，次要针对多个线程在不同工夫申请同一把锁的场景。轻量级锁获取过程：

进行加锁操作时，jvm 会判断是否曾经是重量级锁，如果不是，则会在以后线程栈帧中划出一块空间，作为该锁的锁记录，并且将锁对象 MarkWord 复制到该锁记录中
复制胜利之后，jvm 应用 CAS 操作将对象头 MarkWord 更新为指向锁记录的指针，并将锁记录里的 owner 指针指向对象头的 MarkWord。如果胜利，则执行‘III’，否则执行‘IV’
更新胜利，则以后线程持有该对象锁，并且对象 MarkWord 锁标记设置为‘00’，即示意此对象处于轻量级锁状态
更新失败，jvm 先查看对象 MarkWord 是否指向以后线程栈帧中的锁记录，如果是则执行‘V’，否则执行‘VI’
示意锁重入；而后以后线程栈帧中减少一个锁记录第一局部（Displaced Mark Word）为 null，并指向 Mark Word 的锁对象，起到一个重入计数器的作用
示意该锁对象曾经被其余线程抢占，则进行自旋期待（默认 10 次），期待次数达到阈值仍未获取到锁，则降级为重量级锁

当有多个锁竞争轻量级锁则会降级为重量级锁，重量级锁失常会进入一个 cxq 的队列，在调用 wait 办法之后，则会进入一个 waitSet 的队列 park 期待，而当调用 notify 办法唤醒之后，则有可能进入 EntryList。重量级锁加锁过程:

调配一个 ObjectMonitor 对象，把 Mark Word 锁标记置为‘10’，而后 Mark Word 存储指向 ObjectMonitor 对象的指针。ObjectMonitor 对象有两个队列和一个指针，每个须要获取锁的线程都包装成 ObjectWaiter 对象
多个线程同时执行同一段同步代码时，ObjectWaiter 先进入 EntryList 队列，当某个线程获取到对象的 monitor 当前进入 Owner 区域，并把 monitor 中的 owner 变量设置为以后线程同时 monitor 中的计数器 count+1；

1. 有两个线程同时去批改一个变量的值，比方线程 1、线程 2，都更新变量值，将变量值从 A 更新成 B。

2. 首先线程 1、获取到 CPU 的工夫片，线程 2 因为某些起因产生阻塞进行期待，此时线程 1 进行比拟更新（CompareAndSwap），胜利将变量的值从 A 更新成 B。

3. 更新结束之后，恰好又有线程 3 进来想要把变量的值从 B 更新成 A，线程 3 进行比拟更新，胜利将变量的值从 B 更新成 A。4. 线程 2 获取到 CPU 的工夫片，而后进行比拟更新，发现值是预期的 A，而后又更新成了 B。然而线程 1 并不知道，该值曾经有了 A ->B->A 这个过程，这也就是咱们常说的 ABA 问题。

4. 能够通过加版本号或者加工夫戳解决，或者保障单向递增或者递加就不会存在此类问题。

首先确认业务是 CPU 密集型还是 IO 密集型的，

如果是 CPU 密集型的，那么就应该尽量少的线程数量，个别为 CPU 的核数 +1；

如果是 IO 密集型：所以可多调配一点 cpu 核数 *2 也能够应用公式：CPU 核数 / (1 – 阻塞系数)；其中阻塞系数在 0.8 ～ 0.9 之间。

1、通过共享变量，变量须要 volatile 润饰

2、应用 wait()和 notifyAll()办法，然而因为须要应用同一把锁，所以必须告诉线程开释锁，被告诉线程能力获取到锁，这样导致告诉不及时。

3、应用 CountDownLatch 实现，告诉线程到指定条件，调用 countDownLatch.countDown()，被告诉线程进行 countDownLatch.await()。

4、应用 Condition 的 await()和 signalAll()办法。

润饰静态方法，是对类进行加锁，如果该类中有 methodA 和 methodB 都是被 synchronized 润饰的静态方法，此时有两个线程 T1、T2 别离调用 methodA()和 methodB()，则 T2 会阻塞期待直到 T1 执行实现之后能力执行。

润饰实例办法时，是对实例进行加锁，锁的是实例对象的对象头，如果调用同一个对象的两个不同的被 synchronized 润饰的实例办法时，看到的成果和下面的一样，如果调用不同对象的两个不同的被 synchronized 润饰的实例办法时，则不会阻塞。

两种用法：

1、让主线程 await，业务线程进行业务解决，解决实现时调用 countdownLatch.countDown()，CountDownLatch 实例化的时候须要依据业务去抉择 CountDownLatch 的 count;

2、让业务线程 await，主线程解决完数据之后进行 countdownLatch.countDown()，此时业务线程被唤醒，而后去主线程拿数据，或者执行本人的业务逻辑。

（1）Executor 提供了几种线程池

1、newCachedThreadPool()（工作队列应用的是 SynchronousQueue）

创立一个线程池，如果线程池中的线程数量过大，它能够无效地回收多余的线程，如果线程数有余，那么它可以创立新的线程。

有余：这种形式尽管能够依据业务场景主动的扩大线程数来解决咱们的业务，然而最多须要多少个线程同时处理却是咱们无法控制的。

长处：如果当第二个工作开始，第一个工作曾经执行完结，那么第二个工作会复用第一个工作创立的线程，并不会从新创立新的线程，进步了线程的复用率。

作用：该办法返回一个能够依据理论状况调整线程池中线程的数量的线程池。即该线程池中的线程数量不确定，是依据理论状况动静调整的。

2、newFixedThreadPool()（工作队列应用的是 LinkedBlockingQueue）

这种形式能够指定线程池中的线程数。如果满了后又来了新工作，此时只能排队期待。

长处：newFixedThreadPool 的线程数是能够进行管制的，因而咱们能够通过管制最大线程来使咱们的服务器达到最大的使用率，同时又能够保障即便流量忽然增大也不会占用服务器过多的资源。

作用：该办法返回一个固定线程数量的线程池，该线程池中的线程数量始终不变，即不会再创立新的线程，也不会销毁曾经创立好的线程，一如既往都是那几个固定的线程在工作，所以该线程池能够控制线程的最大并发数

3、newScheduledThreadPool()

该线程池反对定时，以及周期性的工作执行，咱们能够提早工作的执行工夫，也能够设置一个周期性的工夫让工作反复执行。该线程池中有以下两种提早的办法。

scheduleAtFixedRate 不同的中央是工作的执行工夫，如果间隔时间大于工作的执行工夫，工作不受执行工夫的影响。如果间隔时间小于工作的执行工夫，那么工作执行完结之后，会立马执行，至此间隔时间就会被打乱。

scheduleWithFixedDelay 的间隔时间不会受工作执行工夫长短的影响。

作用：该办法返回一个能够控制线程池内线程定时或周期性执行某工作的线程池。

4、newSingleThreadExecutor()

这是一个单线程池，至始至终都由一个线程来执行。

作用：该办法返回一个只有一个线程的线程池，即每次只能执行一个线程工作，多余的工作会保留到一个工作队列中，期待这一个线程闲暇，当这个线程闲暇了再按 FIFO 形式程序执行工作队列中的工作。

5、newSingleThreadScheduledExecutor()只有一个线程，用来调度工作在指定工夫执行。作用：该办法返回一个能够控制线程池内线程定时或周期性执行某工作的线程池。只不过和下面的区别是该线程池大小为 1，而下面的能够指定线程池的大小。

（2）线程池的参数

int corePoolSize,// 线程池外围线程大小

int maximumPoolSize,// 线程池最大线程数量

long keepAliveTime,// 闲暇线程存活工夫

TimeUnit unit,// 闲暇线程存活工夫单位，一共有七种动态属性(TimeUnit.DAYS 天,TimeUnit.HOURS 小时,TimeUnit.MINUTES 分钟,TimeUnit.SECONDS 秒,TimeUnit.MILLISECONDS 毫秒,TimeUnit.MICROSECONDS 奥妙,TimeUnit.NANOSECONDS 纳秒)

BlockingQueue workQueue,// 工作队列

ThreadFactory threadFactory,// 线程工厂，次要用来创立线程 (默认的工厂办法是：Executors.defaultThreadFactory() 对线程进行安全检查并命名)

RejectedExecutionHandler handler// 回绝策略(默认是：ThreadPoolExecutor.AbortPolicy 不执行并抛出异样)

（3）回绝策略

当工作队列中的工作已达到最大限度，并且线程池中的线程数量也达到最大限度，这时如果有新工作提交进来，就会执行回绝策略。

jdk 中提供了 4 种回绝策略：

①ThreadPoolExecutor.CallerRunsPolicy：该策略下，在调用者线程中间接执行被回绝工作的 run 办法，除非线程池曾经 shutdown，则间接摈弃任务。

②ThreadPoolExecutor.AbortPolicy：该策略下，间接抛弃工作，并抛出 RejectedExecutionException 异样。

③ThreadPoolExecutor.DiscardPolicy：该策略下，间接抛弃工作，什么都不做。

④ThreadPoolExecutor.DiscardOldestPolicy：该策略下，摈弃进入队列最早的那个工作，而后尝试把这次回绝的工作放入队列。

除此之外，还能够依据利用场景须要来实现 RejectedExecutionHandler 接口自定义策略。

（4）工作搁置的程序过程

任务调度是线程池的次要入口，当用户提交了一个工作，接下来这个工作将如何执行都是由这个阶段决定的。理解这部分就相当于理解了线程池的外围运行机制。

首先，所有工作的调度都是由 execute 办法实现的，这部分实现的工作是：查看当初线程池的运行状态、运行线程数、运行策略，决定接下来执行的流程，是间接申请线程执行，或是缓冲到队列中执行，亦或是间接回绝该工作。其执行过程如下：

首先检测线程池运行状态，如果不是 RUNNING，则间接回绝，线程池要保障在 RUNNING 的状态下执行工作。

如果 workerCount < corePoolSize，则创立并启动一个线程来执行新提交的工作。

如果 workerCount >= corePoolSize，且线程池内的阻塞队列未满，则将工作增加到该阻塞队列中。

如果 workerCount >= corePoolSize && workerCount < maximumPoolSize，且线程池内的阻塞队列已满，则创立并启动一个线程来执行新提交的工作。

如果 workerCount >= maximumPoolSize，并且线程池内的阻塞队列已满, 则依据回绝策略来解决该工作, 默认的解决形式是间接抛异样。

其执行流程如下图所示：

（5）工作完结后会不会回收线程

final void runWorker(Worker w) {Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {while (task != null || (task = getTask()) != null) {w.lock();
               if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {task.run();
                    } catch (RuntimeException x) {thrown = x; throw x;} catch (Error x) {thrown = x; throw x;} catch (Throwable x) {thrown = x; throw new Error(x);
                    } finally {afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();}
            }
            completedAbruptly = false;
        } finally {processWorkerExit(w, completedAbruptly);
        }
    }

首先线程池内的线程都被包装成了一个个的 java.util.concurrent.ThreadPoolExecutor.Worker, 然后这个 worker 会快马加鞭的执行工作, 执行完工作之后就会在 while 循环中去取工作, 取到工作就继续执行, 取不到工作就跳出 while 循环 (这个时候 worker 就不能再执行工作了) 执行 processWorkerExit 办法, 这个方法呢就是做清场解决, 将以后 woker 线程从线程池中移除, 并且判断是否是异样进入 processWorkerExit 方法, 如果是非异常情况, 就对以后线程池状态 (RUNNING,shutdown) 和当前工作线程数和当前任务数做判断, 是否要退出一个新的线程去实现最初的工作.

（6）未应用的线程池中的线程放在哪里

private final HashSet<Worker> workers = new HashSet<Worker>();

（7）线程池线程存在哪

private final HashSet<Worker> workers = new HashSet<Worker>();

通过办法参数传递; 通过共享变量; 如果在用一个线程中, 还能够应用 ThreadLocal 进行传递.

Thread 类中有两个变量 threadLocals 和 inheritableThreadLocals，二者都是 ThreadLocal 外部类 ThreadLocalMap 类型的变量，咱们通过查看外部内 ThreadLocalMap 能够发现实际上它相似于一个 HashMap。在默认状况下，每个线程中的这两个变量都为 null:

只有当线程第一次调用 ThreadLocal 的 set 或者 get 办法的时候才会创立它们。

除此之外，和我所想的不同的是，每个线程的本地变量不是寄存在 ThreadLocal 实例中，而是放在调用线程的 ThreadLocals 变量外面。也就是说，ThreadLocal 类型的本地变量是寄存在具体的线程空间上，其自身相当于一个装载本地变量的工具壳，通过 set 办法将 value 增加到调用线程的 threadLocals 中，当调用线程调用 get 办法时候可能从它的 threadLocals 中取出变量。如果调用线程始终不终止，那么这个本地变量将会始终寄存在他的 threadLocals 中，所以不应用本地变量的时候须要调用 remove 办法将 threadLocals 中删除不必的本地变量, 防止出现内存透露。

不是偏心锁

以下是 32 位的对象头形容

synchronized 锁的收缩过程：

当线程拜访同步代码块。首先查看以后锁状态是否是偏差锁(可偏差状态)

1、如果是偏差锁：

1.1、查看以后 mark word 中记录是否是以后线程 id，如果是以后线程 id，则取得偏差锁执行同步代码块。

1.2、如果不是以后线程 id，cas 操作替换线程 id，替换胜利取得偏差锁(线程复用)，替换失败锁撤销升级轻量锁(同一类对象屡次撤销降级达到阈值 20，则批量重偏差, 这个点能够略微提一下, 详见上面的留神)

2、降级轻量锁降级轻量锁对于以后线程，调配栈帧锁记录 lock_record(蕴含 mark word 和 object- 指向锁记录首地址)，对象头 mark word 复制到线程栈帧的锁记录 mark word 存储的是无锁的 hashcode(外面有重入次数问题)。

3、重量级锁(纯理论可联合源码)

CAS 自旋达到肯定次数降级为重量级锁(多个线程同时竞争锁时)

存储在 ObjectMonitor 对象，外面有很多属性 ContentionList、EntryList、WaitSet、owner。当一个线程尝试获取锁时，如果该锁曾经被占用，则该线程封装成 ObjectWaiter 对象插到 ContentionList 队列的对首，而后调用 park 挂起。该线程锁时形式会从 ContentionList 或 EntryList 挑一个唤醒。线程取得锁后调用 Object 的 wait 办法，则会退出到 WaitSet 汇合中(以后锁或收缩为重量级锁)

留神:

1. 偏差锁在 JDK1.6 以上默认开启，开启后程序启动几秒后才会被激活

2. 偏差锁撤销是须要在 safe_point, 也就是平安点的时候进行, 这个时候是 stop the word 的, 所以说偏差锁的撤销是开销很大的, 如果明确了我的项目里的竞争状况比拟多, 那么敞开偏差锁能够缩小一些偏差锁撤销的开销

3. 以 class 为单位，为每个 class 保护一个偏差锁撤销计数器。每一次该 class 的对象产生偏差撤销操作时 (这个时候进入轻量级锁)，该计数器 +1，当这个值达到重偏差阈值 (默认 20, 也就是说前 19 次进行加锁的时候, 都是假的轻量级锁, 当第 20 次加锁的时候, 就会走批量冲偏差的逻辑) 时，JVM 就认为该 class 的偏差锁有问题，因而会进行批量重偏差。每个 class 对象也会有一个对应的 epoch 字段，每个处于偏差锁状态对象的 mark word 中也有该字段，其初始值为创立该对象时，class 中的 epoch 值。每次产生批量重偏差时，就将该值 +1，同时遍历 JVM 中所有线程的站，找到该 class 所有正处于加锁状态的偏差锁，将其 epoch 字段改为新值。下次获取锁时，发现以后对象的 epoch 值和 class 不相等，那就算以后曾经偏差了其余线程，也不会执行撤销操作，而是间接通过 CAS 操作将其 mark word 的 Thread Id 改为以后线程 ID

通过加版本号管制，只有有变更，就更新版本号

状态变量 state：

AQS 中定义了一个状态变量 state，它有以下两种应用办法：

（1）互斥锁

当 AQS 只实现为互斥锁的时候，每次只有原子更新 state 的值从 0 变为 1 胜利了就获取了锁，可重入是通过一直把 state 原子更新加 1 实现的。

（2）互斥锁 + 共享锁

当 AQS 须要同时实现为互斥锁 + 共享锁的时候，低 16 位存储互斥锁的状态，高 16 位存储共享锁的状态，次要用于实现读写锁。

互斥锁是一种独占锁，每次只容许一个线程独占，且当一个线程独占时，其它线程将无奈再获取互斥锁及共享锁，然而它本人能够获取共享锁。

共享锁同时容许多个线程占有，只有有一个线程占有了共享锁，所有线程（包含本人）都将无奈再获取互斥锁，然而能够获取共享锁。

AQS 队列

AQS 中保护了一个队列，获取锁失败（非 tryLock()）的线程都将进入这个队列中排队，期待锁开释后唤醒下一个排队的线程（互斥锁模式下）。

condition 队列

AQS 中还有另一个十分重要的外部类 ConditionObject，它实现了 Condition 接口，次要用于实现条件锁。

ConditionObject 中也保护了一个队列，这个队列次要用于期待条件的成立，当条件成立时，其它线程将 signal 这个队列中的元素，将其挪动到 AQS 的队列中，期待占有锁的线程开释锁后被唤醒。

Condition 典型的使用场景是在 BlockingQueue 中的实现，当队列为空时，获取元素的线程阻塞在 notEmpty 条件上，一旦队列中增加了一个元素，将告诉 notEmpty 条件，将其队列中的元素挪动到 AQS 队列中期待被唤醒。

获取锁、开释锁的这些办法基本上都穿插在 ReentrantLock、ReentrantReadWriteLock、Semaphore、CountDownLatch 的源码解析中须要子类实现的办法下面一起学习了 AQS 中几个重要的模板办法，上面咱们再一起学习下几个须要子类实现的办法：

这几个办法为什么不间接定义成形象办法呢？

因为子类只有实现这几个办法中的一部分就能够实现一个同步器了，所以不须要定义成形象办法。

保障线程可见性

避免指令重排序

可见性：

volatile 的性能就是被润饰的变量在被批改后能够立刻同步到主内存，被润饰的变量在每次是用之前都从主内存刷新。实质也是通过内存屏障来实现可见性

写内存屏障（Store Memory Barrier）能够促使处理器将以后 store buffer（存储缓存）的值写回主存。

读内存屏障（Load Memory Barrier）能够促使处理器解决 invalidate queue（生效队列）。进而防止因为 Store Buffer 和 Invalidate Queue 的非实时性带来的问题。

禁止指令重排序：volatile 是通过内存屏障来禁止指令重排序 JMM 内存屏障的策略

在每个 volatile 写操作的后面插入一个 StoreStore 屏障。

在每个 volatile 写操作的前面插入一个 StoreLoad 屏障。

在每个 volatile 读操作的前面插入一个 LoadLoad 屏障。

在每个 volatile 读操作的前面插入一个 LoadStore 屏障。

JDK1.7 中的 ConcurrentHashMap

外部次要是一个 Segment 数组，而数组的每一项又是一个 HashEntry 数组，元素都存在 HashEntry 数组里。因为每次锁定的是 Segment 对象，也就是整个 HashEntry 数组，所以又叫分段锁。

JDK1.8 中的 ConcurrentHashMap

舍弃了分段锁的实现形式，元素都存在 Node 数组中，每次锁住的是一个 Node 对象，而不是某一段数组，所以反对的写的并发度更高。

再者它引入了红黑树，在 hash 抵触重大时，读操作的效率更高。

今日份分享已完结，请大家多多包涵和指导！

关于java:阿里面试官首次分享完整版多线程核心题你准备好跳槽了吗

1. 如何预防死锁？

2. 多线程有哪几种创立形式？

3. 形容一下线程平安沉闷态问题，竞态条件？

4. Java 中的 wait 和 sleep 的区别与分割？

5. 形容一下过程与线程区别？

6. 形容一下 Java 线程的生命周期？

7. 程序开多少线程适合？

8. 形容一下 notify 和 notifyAll 区别？

9. 形容一下 synchronized 和 lock 区别？

10. 简略形容一下 ABA 问题？

11. 实现一下 DCL？

12. 实现一个阻塞队列（用 Condition 写生产者与消费者就）？

13. 实现多个线程程序打印 abc？

14. 服务器 CPU 数量及线程池线程数量的关系？

15. 多线程之间是如何通信的？

16.synchronized 关键字加在静态方法和实例办法的区别?

17.countdownlatch 的用法？

18. 线程池问题：

19.Java 多线程的几种状态及线程各个状态之间是如何切换的？

20. 如何在办法栈中进行数据传递？

21. 形容一下 ThreadLocal 的底层实现模式及实现的数据结构？

22.Sychornized 是否是偏心锁？

23. 形容一下锁的四种状态及降级过程？

23. CAS 的 ABA 问题怎么解决的？

24. 形容一下 AQS？

25. 介绍一下 volatile 的性能？

26.volatile 的可见性和禁止指令重排序怎么实现的？

27. 简要形容一下 ConcurrentHashMap 底层原理？