JAVA JUC编程整理

1. 线程池底层ThreadPoolExecutor底层实现原理

1. 当线程数 < 核心线程数 corePoolSize 时，创建线程。
2. 当线程数 >= 核心线程数，且任务队列未满时，将任务放入任务队列。
3. 当线程数 >= 核心线程数，且任务队列已满
   3.1若线程数 < 最大线程数 ( 2 < 4 )，继续创建线程，最多创建 最大线程数 - 核心线程数
   3.2若线程数 >= 最大线程数，抛出异常，拒绝任务

实际上最多并发执行数 = 核心线程数 + 缓存队列的容量 + 最大线程数 - 核心线程数

2. 线程池队列满了，任务会丢失吗？

会丢失，但是一般不让丢失，不科学。

一般我们如果队列满了，且任务总数>最大线程数则当前线程走拒绝策略。

1. AbortPolicy 丢弃任务，抛运行时异常
2. CallerRunsPolicy 执行任务
3. DiscardPolicy 忽视，什么都不会发生
4. DiscardOldestPolicy 从队列中踢出最先进入队列（最后一个执行）的任务
5. 可以自定义拒绝异常，将该任务缓存到redis、本地文件、mysql中后期项目启动实现补偿。

3. 线程池拒绝策略类型有哪些呢？

1. new ThreadPoolExecutor.AbortPolicy()； 丢弃任务，抛运行时异常
2. new ThreadPoolExecutor.CallerRunsPolicy() ** 丢给主线程 执行任务**
3. new ThreadPoolExecutor.DiscardPolicy() 忽视，什么都不会发生
4. new ThreadPoolExecutor.DiscardOldestPolicy() 从队列中踢出最先进入队列（最后一个执行）的任务
5. 实现RejectedExecutionHandler 自定义处理策略。

4. 为什么阿里巴巴 不建议使用 Executors?

因为默认的Executors线程池底层是基于ThreadPoolExecutor,构造函数封装的，采用无界队列存放缓存任务，会无限缓存任务容易发生内存溢出，会导致我们最大线程数会失效。

5. 什么是悲观锁？ 什么是乐观锁？

在mysql 层面， 如果有多个事务去执行 修改操作， 只有一个事务会去抢行锁，抢锁成功，其他线程都陷入等待， 那么这就是悲观锁。

在java 层面， 多个线程去抢夺一个资源过程中， 也就是一个线程抢到了获取这个资源的锁成功， 其他线程想要再次利用这个资源， 那么就会在锁外去等待以及唤醒， 这个过程中，线程 在阻塞状态，从唤醒线程， 进入到 就绪状态，成本非常高。 然后 CPU 会从 就绪状态 调度到 运行态， 这个过程非常消耗资源的，所以称之为悲观锁。

乐观锁： 采用的是通过预值和版本号的方式，如果不一致， 采用循环控制修改，当前线程不会被阻塞，是乐观，效率比较高，但是比较消耗资源。
获取锁----如果没有获取到锁，当前线程是不会阻塞等待，而是通过死循环控制。
乐观锁属于无锁机制，没有竞争锁流程。

6.Mysql 层面如何实现乐观锁呢？

在我们表结构中，会新增一个字段就是版本字段
version varchar(255) DEFAULT NULL, 多个线程对同一行数据实现修改操作，提前查询当前最新的 version 版本号码，
作为 update 条件查询，如果当前 version 版本号码发生了变化，则查询不到该数据。
表示如果修改数据失败，则不断重试 ，有从新查询最新的版本实现 update。
需要注意控制乐观锁循环的次数，避免 cpu 飙高的问题。
mysql 的 innodb 引擎中存在行锁的概念

7. 锁的分类有哪些？

1. 悲观锁、乐观锁
2. 自旋锁 和 可重入锁
3. 公平锁 和 非公平锁
4. 重量级锁 和轻量级锁
5. 独占锁 和 共享锁

8. 公平锁 和 非公平锁有什么特性和区别？

• 公平锁：就是比较公平，根据请求锁的顺序排列，先来请求的就先获取锁，后来获取锁就最后获取到， 采用队列存放 类似于吃饭排队。

• 非公平锁：不是据请求的顺序排列， 通过争抢的方式获取锁。

• 非公平锁效率比公平锁效率要高，Synchronized 是非公平锁。

New ReentrantLock(true)—公平锁
New ReentrantLock(false)—非公平锁
底层基于 aqs 实现

9. 公平锁底层是如何实现的?

公平锁：就是比较公平，根据请求锁的顺序排列，先来请求的就先获取锁，后来获取锁就最后获取到，采用队列存放类似于吃饭排队。
队列—底层实现方式 - 链表实现.

10. 什么是锁的可重入性?

在同一个线程中，锁可以不断传递的，可以直接获取到。 这就是锁的可重入性。

synchronized / Lock
aqs

11. 独占锁与共享锁之间的区别？

• 独占锁：在多线程中，只允许有一个线程获取到锁，其他线程都会等待。
• 共享锁：多个线程可以同时持有锁，例如ReentrantLock读写锁。读读可以共享、写写互斥、读写互斥、写读互斥。

12. 什么是CAS（自旋锁），它的优缺点？

自旋锁： 没有获取到锁的线程是不会阻塞的，通过循环控制一直不断的获取锁。

1. Cas 是通过硬件指令，保证原子性
2. Java 是通过 unsafe jni 技术
   原子类： AtomicBoolean，AtomicInteger，AtomicLong 等使用 CAS 实现。

优点：没有获取到锁的线程，会一直在运行态，不会阻塞，没有锁的线程会一直通过循环控制重试。
缺点：通过死循环控制，消耗 cpu 资源比较高，需要控制循次数，避免 cpu 飙高问题；

Cas 本质的原理：
旧的预期值===v(共享变量中值)，才会修改我们 v。

基于 cas 实现锁机制原理

Cas 无锁机制原理：

1. 定义一个锁的状态；
2. 状态状态值=0 则表示没有线程获取到该锁；
3. 状态状态值=1 则表示有线程已经持有该锁；
   实现细节：
   CAS 获取锁：
   将该锁的状态从 0 改为 1-----能够修改成功 cas 成功则表示获取锁成功
   如果获取锁失败–修改失败，则不会阻塞而是通过循环（自旋来控制重试）
   CAS 释放锁：
   将该锁的状态从 1 改为 0 如果能够改成功 cas 成功则表示释放锁成功。

13. 谈谈 Lock 锁底层实现原理

底层基于 AQS + CAS + LockSupport锁实现的。

14. Synchronized 与 Lock 锁之间的区别？

区别	Synchronized	Lock
是个啥？	关键字	接口
作用是啥？	隐式地加锁	显式地加锁
作用位置？	可以作用在方法上、方法块上	方法块上
底层用的啥？	objectMonitor	AQS + CAS + LockSupport
加锁方式	阻塞式加锁	lock是非阻塞式加锁支持可中断式加锁,支持超时时间的加锁
加锁解锁过程	synchronized在进行加锁解锁时,只有一个同步队列和一个等待队列	lock有一个同步队列,可以有多个等待队列
支持	synchronized只支持非公平锁	lock支持非公平锁和公平锁
咋用等待和唤醒啊？	synchronized使用了object类的wait和notify进行等待和唤醒	lock使用了condition接口进行等待和唤醒(await和signal)
—	—	lock支持个性化定制, 使用了模板方法模式,可以自行实现lock方法

相同点：

1. Lock是一个接口，为了使用一个Lock对象，需要用到；
2. Lock lock = new ReentrantLock();
3. 与 synchronized (someObject) 类似的，lock()方法，表示当前线程占用lock对象，一旦占用，其他线程就不能占用了；
4. 与synchronized 不同的是，一旦synchronized 块结束，就会自动释放对someObject的占用。 lock却必须调用unlock方法进行手动释放，为了保证释放的执行，往往会把unlock() 放在finally中进行；
5. synchronized 是不占用到手不罢休的，会一直试图占用下去；
6. 与 synchronized 的钻牛角尖不一样，Lock接口还提供了一个trylock方法；
7. trylock会在指定时间范围内试图占用。 如果时间到了，还占用不成功，就选择放弃；注意： 因为使用trylock有可能成功，有可能失败，所以后面unlock释放锁的时候，需要判断是否占用成功了，如果没占用成功也unlock,就会抛出异常；
8. 使用synchronized方式进行线程交互，用到的是同步对象的wait,notify和notifyAll方法；
9. Lock也提供了类似的解决办法，首先通过lock对象得到一个Condition对象，然后分别调用这个Condition对象的：await, signal,signalAll 方法；
   注意： 不是Condition对象的wait,nofity,notifyAll方法,是await,signal,signalAll；

不同点：

1. Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现，Lock是代码层面的实现；
2. Lock可以选择性的获取锁，如果一段时间获取不到，可以放弃。synchronized不行，会一根筋一直获取下去。 借助Lock的这个特性，就能够规避死锁，synchronized必须通过谨慎和良好的设计，才能减少死锁的发生；
3. synchronized在发生异常和同步块结束的时候，会自动释放锁。而Lock必须手动释放， 所以如果忘记了释放锁，一样会造成死锁。

15. LockSupport的使用

public class LockSupportTest {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "start");
            //当前线程阻塞
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + "end");
        });
        thread.start();
        try {
            Thread.sleep(3000);
            //唤醒阻塞的线程！
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        LockSupport.unpark(thread);
        System.out.println(Thread.currentThread().getName() + "");
    }
}

16. Semaphore 信号量底层原理 (AQS)

Semaphore.acquire(); // 获取信号量， 同时放行执行
Semaphore.release(); // 释放信号量， 才能重新执行。

17. CountDowmLatch 底层原理 (AQS)

//初始值设置
CountDownLatch countdownLatch = new countdownLatch(1);

countdownLatch.await();

//执行减1的操作。
countdownLatch.countDown(); // 为0 ， 执行唤醒。

18.谈谈强、软、弱、虚引用 区别

• 强引用： 当内存不足时，JVM 开始进行 GC(垃圾回收)，对于强引用对象，就算是出现了
  OOM 也不会对该对象进行回收，死都不会收。
• 软引用：当系统内存充足的时候，不会被回收；当系统内存不足时，它会被回收，软引用通
  常用在对内存敏感的 程序中，比如高速缓存就用到软引用，内存够用时就保留，不够时就
  回收。
• 弱引用：弱引用需要用到 java.lang.ref.WeakReference 类来实现，它比软引用的生存周期更短。
  对于只有弱引用的对象来说，只要有垃圾回收，不管 JVM 的内存空间够不够用，都会回收
  该对象占用的内存空间。
• 虚：虚引用需要 java.lang.ref.Phantomreference 类来实现。顾名思义，虚引用就是形同虚设。
  与其它几种引用不同，虚引用并不会决定对象的声明周期。