## 前言大家好，我是**捡田螺的小男孩**。金九银十快要来了，整理了50道多线程并发面试题，大家可以点赞、收藏起来，慢慢品！~ - [github地址](https://github.com/whx123/JavaHome)，麻烦给个star鼓励一下，感谢感谢 - 公众号：捡田螺的小男孩（欢迎关注，干货多多） ## 1、为什么要使用多线程选择多线程的原因，就是因为快。举个例子： > 如果要**把1000块砖搬到楼顶**，假设到楼顶有几个电梯，你觉得用一个电梯搬运快，还是同时用几个电梯同时搬运快呢？这个电梯就可以理解为线程。 ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/7ef1b69c46e3438f93663535e431ff4d~tplv-k3u1fbpfcp-zoom-1.image) 所以，我们使用多线程就是因为： **在正确的场景下，设置恰当数目的线程，可以用来程提高序的运行速率。更专业点讲，就是充分地利用CPU和I/O的利用率，提升程序运行速率。** 当然，有利就有弊，多线程场景下，我们要保证线程安全，就需要考虑加锁。加锁如果不恰当，就很很耗性能。 ## 2. 创建线程有几种方式？ ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f79dc95501ff4f43a61fb415eab14506~tplv-k3u1fbpfcp-zoom-1.image) Java中创建线程主要有以下这几种方式： - 定义```Thread```类的子类，并重写该类的```run```方法 - 定义```Runnable```接口的实现类，并重写该接口的```run()```方法 - 定义```Callable```接口的实现类，并重写该接口的```call()```方法，一般配合```Future```使用 - 线程池的方式 ### 2.1 定义Thread类的子类，并重写该类的run方法 ``` public class ThreadTest { public static void main(String[] args) { Thread thread = new MyThread(); thread.start(); } } class MyThread extends Thread { @Override public void run() { System.out.println("关注公众号:捡田螺的小男孩"); } } ``` ### 2.2 定义Runnable接口的实现类，并重写该接口的run()方法 ``` public class ThreadTest { public static void main(String[] args) { MyRunnable myRunnable = new MyRunnable(); Thread thread = new Thread(myRunnable); thread.start(); } } class MyRunnable implements Runnable { @Override public void run() { System.out.println("关注公众号:捡田螺的小男孩"); } } //运行结果：关注公众号:捡田螺的小男孩 ``` ### 2.3 定义Callable接口的实现类，并重写该接口的call()方法如果想要执行的线程有返回，可以使用```Callable```。 ``` public class ThreadTest { public static void main(String[] args) throws ExecutionException, InterruptedException { MyThreadCallable mc = new MyThreadCallable(); FutureTask ft = new FutureTask<>(mc); Thread thread = new Thread(ft); thread.start(); System.out.println(ft.get()); } } class MyThreadCallable implements Callable { @Override public String call()throws Exception { return "关注公众号:捡田螺的小男孩"; } } //运行结果：关注公众号:捡田螺的小男孩 ``` ### 2.4 线程池的方式日常开发中，我们一般都是用线程池的方式执行异步任务。 ``` public class ThreadTest { public static void main(String[] args) throws Exception { ThreadPoolExecutor executorOne = new ThreadPoolExecutor(5, 5, 1, TimeUnit.MINUTES, new ArrayBlockingQueue(20), new CustomizableThreadFactory("Tianluo-Thread-pool")); executorOne.execute(() -> { System.out.println("关注公众号：捡田螺的小男孩"); }); //关闭线程池 executorOne.shutdown(); } } ``` ## 3. start()方法和run()方法的区别其实```start```和```run```的主要区别如下： - ```start```方法可以启动一个新线程，```run```方法只是类的一个普通方法而已，如果直接调用```run```方法，程序中依然只有主线程这一个线程。 - ```start```方法实现了多线程，而```run```方法没有实现多线程。 - ```start```不能被重复调用，而```run```方法可以。 - ```start```方法中的```run```代码可以不执行完，就继续执行下面的代码，也就是说进行了**线程切换**。然而，如果直接调用```run```方法，就必须等待其代码全部执行完才能继续执行下面的代码。大家可以结合代码例子来看看哈~ ``` public class ThreadTest { public static void main(String[] args){ Thread t=new Thread(){ public void run(){ pong(); } }; t.start(); t.run(); t.run(); System.out.println("好的，马上去关注：捡田螺的小男孩"+ Thread.currentThread().getName()); } static void pong(){ System.out.println("关注公众号：捡田螺的小男孩"+ Thread.currentThread().getName()); } } //输出关注公众号：捡田螺的小男孩main 关注公众号：捡田螺的小男孩main 好的，马上去关注：捡田螺的小男孩main 关注公众号：捡田螺的小男孩Thread-0 ``` ## 4. 线程和进程的区别 - 进程是运行中的应用程序，线程是进程的内部的一个执行序列 - 进程是资源分配的最小单位，线程是CPU调度的最小单位。 - 一个进程可以有多个线程。线程又叫做轻量级进程，多个线程共享进程的资源 - 进程间切换代价大，线程间切换代价小 - 进程拥有资源多，线程拥有资源少地址 - 进程是存在地址空间的，而线程本身无地址空间，线程的地址空间是包含在进程中的 **举个例子：** > 你打开QQ，开了一个进程；打开了迅雷，也开了一个进程。 > > 在QQ的这个进程里，传输文字开一个线程、传输语音开了一个线程、弹出对话框又开了一个线程。 > > 所以运行某个软件，相当于开了一个进程。在这个软件运行的过程里（在这个进程里），多个工作支撑的完成QQ的运行，那么这“多个工作”分别有一个线程。 > > 所以一个进程管着多个线程。 > > 通俗的讲：“进程是爹妈，管着众多的线程儿子”... ## 5. 说一下 Runnable和 Callable有什么区别？ - ```Runnable```接口中的```run()```方法没有返回值，是```void```类型，它做的事情只是纯粹地去执行```run()```方法中的代码而已； - ```Callable```接口中的```call()```方法是有返回值的，是一个泛型。它一般配合```Future、FutureTask```一起使用，用来获取异步执行的结果。 - ```Callable```接口```call()```方法允许抛出异常；而```Runnable```接口```run()```方法不能继续上抛异常；大家可以看下它俩的```API```: ``` @FunctionalInterface public interface Callable { /** * 支持泛型V，有返回值，允许抛出异常 */ V call() throws Exception; } @FunctionalInterface public interface Runnable { /** * 没有返回值，不能继续上抛异常 */ public abstract void run(); } ``` 为了方便大家理解，写了一个demo，小伙伴们可以看看哈： ``` /* * @Author 关注公众号：捡田螺的小男孩 * @date 2022-07-11 */ public class CallableRunnableTest { public static void main(String[] args) { ExecutorService executorService = Executors.newFixedThreadPool(5); Callable callable =new Callable() { @Override public String call() throws Exception { return "你好，callable,关注公众号：捡田螺的小男孩"; } }; //支持泛型 Future futureCallable = executorService.submit(callable); try { System.out.println("获取callable的返回结果："+futureCallable.get()); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } Runnable runnable = new Runnable() { @Override public void run() { System.out.println("你好呀,runnable，关注公众号：捡田螺的小男孩"); } }; Future futureRunnable = executorService.submit(runnable); try { System.out.println("获取runnable的返回结果："+futureRunnable.get()); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } executorService.shutdown(); } } //运行结果获取callable的返回结果：你好，callable,关注公众号：捡田螺的小男孩你好呀,runnable，关注公众号：捡田螺的小男孩获取runnable的返回结果：null ``` ## 6. 聊聊volatile作用，原理 volatile关键字是Java虚拟机提供的的最轻量级的同步机制。它作为一个修饰符，用来修饰变量。**它保证变量对所有线程可见性，禁止指令重排，但是不保证原子性**。我们先来一起回忆下java内存模型（jmm）： - Java虚拟机规范试图定义一种Java内存模型,来屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台上都能达到一致的内存访问效果。 - Java内存模型规定所有的变量都是存在主内存当中，每个线程都有自己的工作内存。这里的变量包括实例变量和静态变量，但是不包括局部变量，因为局部变量是线程私有的。 - 线程的工作内存保存了被该线程使用的变量的主内存副本，线程对变量的所有操作都必须在工作内存中进行，而不能直接操作主内存。并且每个线程不能访问其他线程的工作内存。 ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/fd2def31b5c145368df64d7de5d78565~tplv-k3u1fbpfcp-zoom-1.image) volatile变量，保证新值能立即同步回主内存，以及每次使用前立即从主内存刷新，所以我们说volatile保证了多线程操作变量的可见性。 volatile保证可见性和禁止指令重排，都跟内存屏障有关。我们来看一段volatile使用的demo代码： ``` /** * 关注公众号：捡田螺的小男孩 **/ public class Singleton { private volatile static Singleton instance; private Singleton (){} public static Singleton getInstance() { if (instance == null) { synchronized (Singleton.class) { if (instance == null) { instance = new Singleton(); } } } return instance; } } ``` 编译后，对比有```volatile```关键字和没有```volatile```关键字时所生成的汇编代码，发现有```volatile```关键字修饰时，会多出一个```lock addl $0x0,(%esp)```，即多出一个lock前缀指令，lock指令相当于一个内存屏障 ```lock```指令相当于一个内存屏障，它保证以下这几点： 1. 重排序时不能把后面的指令重排序到内存屏障之前的位置 2. 将本处理器的缓存写入内存 3. 如果是写入动作，会导致其他处理器中对应的缓存无效。第2点和第3点就是保证```volatile```保证可见性的体现嘛，第1点就是**禁止指令重排的体现**。内存屏障四大分类：（Load 代表读取指令，Store代表写入指令） ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/8a94e905b5f047ec9bdaa56324891fba~tplv-k3u1fbpfcp-zoom-1.image) - 在每个volatile写操作的前面插入一个StoreStore屏障。 - 在每个volatile写操作的后面插入一个StoreLoad屏障。 - 在每个volatile读操作的后面插入一个LoadLoad屏障。 - 在每个volatile读操作的后面插入一个LoadStore屏障。有些小伙伴，可能对这个还是有点疑惑，内存屏障这玩意太抽象了。我们照着代码看下吧： ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/608be0a8a12e44998b71d49591199d46~tplv-k3u1fbpfcp-zoom-1.image) 内存屏障保证前面的指令先执行，所以这就保证了禁止了指令重排啦，同时内存屏障保证缓存写入内存和其他处理器缓存失效，这也就保证了可见性，哈哈~有关于volatile的底层实现，我们就讨论到这哈~ ## 7. 说说并发与并行的区别? 并发和并行最开始都是**操作系统**中的概念，表示的是CPU执行多个任务的方式。 - 顺序：上一个开始执行的任务完成后，当前任务才能开始执行 - 并发：无论上一个开始执行的任务是否完成，当前任务都可以开始执行（即 A B 顺序执行的话，A 一定会比 B 先完成，而并发执行则不一定。） - 串行：有一个任务执行单元，从物理上就只能一个任务、一个任务地执行 - 并行：有多个任务执行单元，从物理上就可以多个任务一起执行（即在任意时间点上，串行执行时必然只有一个任务在执行，而并行则不一定。） **知乎有个很有意思的回答**，大家可以看下： > - 你吃饭吃到一半，电话来了，你一直到吃完了以后才去接，这就说明你不支持并发也不支持并行。 > - 你吃饭吃到一半，电话来了，你停了下来接了电话，接完后继续吃饭，这说明你支持并发。 > - 你吃饭吃到一半，电话来了，你一边打电话一边吃饭，这说明你支持并行。 > > 并发的关键是你有处理多个任务的能力，不一定要同时。并行的关键是你有同时处理多个任务的能力。所以我认为它们最关键的点就是：是否是**同时**。 > > 来源：知乎 ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/11dee385e2434d85b8dcb28491c272f2~tplv-k3u1fbpfcp-zoom-1.image) ## 8.synchronized 的实现原理以及锁优化？ synchronized是Java中的关键字，是一种同步锁。synchronized关键字可以作用于方法或者代码块。一般面试时。可以这么回答： ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/0aaa1893f0c7416fb851559860748a84~tplv-k3u1fbpfcp-zoom-1.image) ### 8.1 monitorenter、monitorexit、ACC_SYNCHRONIZED 如果**synchronized**作用于**代码块**，反编译可以看到两个指令：```monitorenter、monitorexit```，JVM使用```monitorenter和monitorexit```两个指令实现同步；如果作用synchronized作用于**方法**,反编译可以看到```ACCSYNCHRONIZED标记```，JVM通过在方法访问标识符(flags)中加入```ACCSYNCHRONIZED```来实现同步功能。 - 同步代码块是通过```monitorenter和monitorexit```来实现，当线程执行到monitorenter的时候要先获得monitor锁，才能执行后面的方法。当线程执行到monitorexit的时候则要释放锁。 - 同步方法是通过中设置ACCSYNCHRONIZED标志来实现，当线程执行有ACCSYNCHRONI标志的方法，需要获得monitor锁。每个对象都与一个monitor相关联，线程可以占有或者释放monitor。 ### 8.2 monitor监视器 monitor是什么呢？操作系统的管程（monitors）是概念原理，ObjectMonitor是它的原理实现。 ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/cc9b523b61af4e0687f0e629cb386e91~tplv-k3u1fbpfcp-zoom-1.image) 在Java虚拟机（HotSpot）中，Monitor（管程）是由ObjectMonitor实现的，其主要数据结构如下： ``` ObjectMonitor() { _header = NULL; _count = 0; // 记录个数 _waiters = 0, _recursions = 0; _object = NULL; _owner = NULL; _WaitSet = NULL; // 处于wait状态的线程，会被加入到_WaitSet _WaitSetLock = 0 ; _Responsible = NULL ; _succ = NULL ; _cxq = NULL ; FreeNext = NULL ; _EntryList = NULL ; // 处于等待锁block状态的线程，会被加入到该列表 _SpinFreq = 0 ; _SpinClock = 0 ; OwnerIsThread = 0 ; } ``` ObjectMonitor中几个关键字段的含义如图所示： ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/cd1caed9fd62436a918e288df8b9f27f~tplv-k3u1fbpfcp-zoom-1.image) ### 8.3 Java Monitor 的工作机理 ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/86fe8d668da5415287edd216cd64de13~tplv-k3u1fbpfcp-zoom-1.image) - 想要获取monitor的线程,首先会进入_EntryList队列。 - 当某个线程获取到对象的monitor后,进入Owner区域，设置为当前线程,同时计数器count加1。 - 如果线程调用了wait()方法，则会进入WaitSet队列。它会释放monitor锁，即将owner赋值为null,count自减1,进入WaitSet队列阻塞等待。 - 如果其他线程调用 notify() / notifyAll() ，会唤醒WaitSet中的某个线程，该线程再次尝试获取monitor锁，成功即进入Owner区域。 - 同步方法执行完毕了，线程退出临界区，会将monitor的owner设为null，并释放监视锁。 ### 8.4 对象与monitor关联 ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/c6b59e9a0b69491a9afe2906e2e6bd8b~tplv-k3u1fbpfcp-zoom-1.image) - 在HotSpot虚拟机中,对象在内存中存储的布局可以分为3块区域：**对象头（Header），实例数据（Instance Data）和对象填充（Padding）**。 - 对象头主要包括两部分数据：**Mark Word（标记字段）、Class Pointer（类型指针）**。 Mark Word 是用于存储对象自身的运行时数据，如哈希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程 ID、偏向时间戳等。 ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/bce5b121d8a448ec930b4519b3f27a4a~tplv-k3u1fbpfcp-zoom-1.image) **重量级锁，指向互斥量的指针。其实synchronized是重量级锁，也就是说Synchronized的对象锁，Mark Word锁标识位为10，其中指针指向的是Monitor对象的起始地址。** ## 9. 线程有哪些状态？线程有6个状态,分别是：```New, Runnable, Blocked, Waiting, Timed_Waiting, Terminated```。转换关系图如下： ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/21fdd2d8e3b64072a85357509b3b23cb~tplv-k3u1fbpfcp-zoom-1.image) - New：线程对象创建之后、但还没有调用```start()```方法，就是这个状态。 ``` /** * 关注公众号：捡田螺的小男孩 */ public class ThreadTest { public static void main(String[] args) { Thread thread = new Thread(); System.out.println(thread.getState()); } } //运行结果： NEW ``` - Runnable：它包括就绪（```ready```）和运行中（```running```）两种状态。如果调用```start```方法，线程就会进入```Runnable```状态。它表示我这个线程可以被执行啦（此时相当于```ready```状态），如果这个线程被调度器分配了CPU时间，那么就可以被执行（此时处于```running```状态）。 ``` public class ThreadTest { public static void main(String[] args) { Thread thread = new Thread(); thread.start(); System.out.println(thread.getState()); } } //运行结果： RUNNABLE ``` - Blocked：阻塞的（被同步锁或者IO锁阻塞）。表示线程阻塞于锁，线程阻塞在进入```synchronized```关键字修饰的方法或代码块(**等待获取锁**)时的状态。比如前面有一个临界区的代码需要执行，那么线程就需要等待，它就会进入这个状态。它一般是从```RUNNABLE```状态转化过来的。如果线程获取到锁，它将变成```RUNNABLE```状态 ``` Thread t = new Thread(new Runnable { void run() { synchronized (lock) { // 阻塞于这里，变为Blocked状态 // dothings } } }); t.getState(); //新建之前，还没开始调用start方法，处于New状态 t.start(); //调用start方法，就会进入Runnable状态 ``` - WAITING : 永久等待状态，进入该状态的线程需要等待其他线程做出一些特定动作（比如通知）。处于该状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态。一般```Object.wait```。 ``` Thread t = new Thread(new Runnable { void run() { synchronized (lock) { // Blocked // dothings while (!condition) { lock.wait(); // into Waiting } } } }); t.getState(); // New t.start(); // Runnable ``` - TIMED_WATING: 等待指定的时间重新被唤醒的状态。有一个计时器在里面计算的，最常见就是使用```Thread.sleep```方法触发，触发后，线程就进入了```Timed_waiting```状态，随后会由计时器触发，再进入```Runnable```状态。 ``` Thread t = new Thread(new Runnable { void run() { Thread.sleep(1000); // Timed_waiting } }); t.getState(); // New t.start(); // Runnable ``` - 终止(TERMINATED)：表示该线程已经执行完成。再来看个代码demo吧： ``` /** * 关注公众号：捡田螺的小男孩 */ public class ThreadTest { private static Object object = new Object(); public static void main(String[] args) throws Exception { Thread thread = new Thread(new Runnable() { @Override public void run() { try { for(int i = 0; i< 1000; i++){ System.out.print(""); } Thread.sleep(500); synchronized (object){ object.wait(); } } catch (InterruptedException e) { e.printStackTrace(); } } }); Thread thread1 = new Thread(new Runnable() { @Override public void run() { try { synchronized (object){ Thread.sleep(1000); } Thread.sleep(1000); synchronized (object){ object.notify(); } } catch (InterruptedException e) { e.printStackTrace(); } } }); System.out.println("1"+thread.getState()); thread.start(); thread1.start(); System.out.println("2"+thread.getState()); while (thread.isAlive()){ System.out.println("---"+thread.getState()); Thread.sleep(100); } System.out.println("3"+thread.getState()); } } 运行结果: 1NEW 2RUNNABLE ---RUNNABLE ---TIMED_WAITING ---TIMED_WAITING ---TIMED_WAITING ---TIMED_WAITING ---BLOCKED ---BLOCKED ---BLOCKED ---BLOCKED ---BLOCKED ---WAITING ---WAITING ---WAITING ---WAITING ---WAITING ---WAITING ---WAITING ---WAITING ---WAITING ``` ## 10. synchronized和ReentrantLock的区别？ - ```Synchronized```是依赖于```JVM```实现的，而```ReenTrantLock```是```API```实现的。 - 在```Synchronized```优化以前，```synchronized```的性能是比```ReenTrantLock```差很多的，但是自从```Synchronized```引入了偏向锁，轻量级锁（自旋锁）后，两者性能就差不多了。 - ```Synchronized```的使用比较方便简洁，它由编译器去保证锁的加锁和释放。而```ReenTrantLock```需要手工声明来加锁和释放锁，最好在finally中声明释放锁。 - ```ReentrantLock```可以指定是公平锁还是⾮公平锁。⽽```synchronized```只能是⾮公平锁。 - ```ReentrantLock```可响应中断、可轮回，而```Synchronized```是不可以响应中断的 ## 11. wait(),notify()和suspend(),resume()之间的区别 - ```wait()```方法使得线程进入阻塞等待状态，并且释放锁 - ```notify()```唤醒一个处于等待状态的线程，它一般跟```wait（）```方法配套使用。 - ```suspend()```使得线程进入阻塞状态，并且不会自动恢复，必须对应的```resume()```被调用，才能使得线程重新进入可执行状态。```suspend()```方法很容易引起死锁问题。 - ```resume()```方法跟```suspend()```方法配套使用。 **suspend()不建议使用**,因为```suspend()```方法在调用后，线程不会释放已经占有的资源（比如锁），而是占有着资源进入睡眠状态，这样容易引发死锁问题。 ## 12. CAS？CAS 有什么缺陷，如何解决？ ```CAS```,全称是```Compare and Swap```，翻译过来就是比较并交换； ```CAS```涉及3个操作数，内存地址值V，预期原值A，新值B；如果内存位置的值V与预期原A值相匹配，就更新为新值B，否则不更新 **CAS有什么缺陷？** ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/4edb31f1346648088db9c199ebf6ce57~tplv-k3u1fbpfcp-zoom-1.image) - **ABA 问题** 并发环境下，假设初始条件是A，去修改数据时，发现是A就会执行修改。但是看到的虽然是A，中间可能发生了A变B，B又变回A的情况。此时A已经非彼A，数据即使成功修改，也可能有问题。可以通过```AtomicStampedReference``` **解决ABA问题**，它，一个带有标记的原子引用类，通过控制变量值的版本来保证CAS的正确性。 - **循环时间长开销** 自旋CAS，如果一直循环执行，一直不成功，会给CPU带来非常大的执行开销。很多时候，CAS思想体现，是有个自旋次数的，就是为了避开这个耗时问题~ - **只能保证一个变量的原子操作。** CAS 保证的是对一个变量执行操作的原子性，如果对多个变量操作时，CAS 目前无法直接保证操作的原子性的。可以通过这两个方式解决这个问题：1. 使用互斥锁来保证原子性； 2.将多个变量封装成对象，通过AtomicReference来保证原子性。有兴趣的朋友可以看看我之前的这篇实战文章哈~[CAS乐观锁解决并发问题的一次实践](https://mp.weixin.qq.com/s?__biz=Mzg3NzU5NTIwNg==&mid=2247487937&idx=1&sn=206a37bf6d6a7aa1d05674c479ed7a72&source=41#wechat_redirect) ## 13. 说说CountDownLatch与CyclicBarrier 区别 ```CountDownLatch和CyclicBarrier```都用于让线程等待，达到一定条件时再运行。主要区别是： - CountDownLatch：一个或者多个线程，等待其他多个线程完成某件事情之后才能执行; - CyclicBarrier：多个线程互相等待，直到到达同一个同步点，再继续一起执行。 ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/3a606180e0ce48d28080b7ddba5403b0~tplv-k3u1fbpfcp-zoom-1.image) 举个例子吧： > - CountDownLatch：假设老师跟同学约定周末在公园门口集合，等人齐了再发门票。那么，发门票（这个主线程），需要等各位同学都到齐（多个其他线程都完成），才能执行。 > - CyclicBarrier:多名短跑运动员要开始田径比赛，只有等所有运动员准备好，裁判才会鸣枪开始，这时候所有的运动员才会疾步如飞。 ## 14. 什么是多线程环境下的伪共享 ### 14.1 什么是伪共享？ > CPU的缓存是以缓存行(cache line)为单位进行缓存的，当多个线程修改相互独立的变量，而这些变量又处于同一个缓存行时就会影响彼此的性能。这就是伪共享现代计算机计算模型: ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/2939c79bc29743c0b1a8c25110476f0c~tplv-k3u1fbpfcp-zoom-1.image) - CPU执行速度比内存速度快好几个数量级，为了提高执行效率，现代计算机模型演变出CPU、缓存（L1，L2，L3），内存的模型。 - CPU执行运算时，如先从L1缓存查询数据，找不到再去L2缓存找，依次类推，直到在内存获取到数据。 - 为了避免频繁从内存获取数据，聪明的科学家设计出缓存行，缓存行大小为64字节。也正是因为**缓存行的存在**，就导致了伪共享问题，如图所示： ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/4649f7c060ae4e65a40dcdad3d4cbb43~tplv-k3u1fbpfcp-zoom-1.image) 假设数据```a、b```被加载到同一个缓存行。 - 当线程1修改了a的值，这时候CPU1就会通知其他CPU核，当前缓存行（Cache line）已经失效。 - 这时候，如果线程2发起修改b，因为缓存行已经失效了，所以「core2 这时会重新从主内存中读取该 Cache line 数据」。读完后，因为它要修改b的值，那么CPU2就通知其他CPU核，当前缓存行（Cache line）又已经失效。 - 酱紫，如果同一个Cache line的内容被多个线程读写，就很容易产生相互竞争，频繁回写主内存，会大大降低性能。 ### 14.2 如何解决伪共享问题既然伪共享是因为相互独立的变量存储到相同的Cache line导致的，一个缓存行大小是64字节。那么，我们就可以使用**空间换时间**的方法，即**数据填充的方式**，把独立的变量分散到不同的Cache line~ 来看个例子: ``` /** * 更多干货内容，关注公众号：捡田螺的小男孩 */ public class FalseShareTest { public static void main(String[] args) throws InterruptedException { Rectangle rectangle = new Rectangle(); long beginTime = System.currentTimeMillis(); Thread thread1 = new Thread(() -> { for (int i = 0; i < 100000000; i++) { rectangle.a = rectangle.a + 1; } }); Thread thread2 = new Thread(() -> { for (int i = 0; i < 100000000; i++) { rectangle.b = rectangle.b + 1; } }); thread1.start(); thread2.start(); thread1.join(); thread2.join(); System.out.println("执行时间" + (System.currentTimeMillis() - beginTime)); } } class Rectangle { volatile long a; volatile long b; } //运行结果：执行时间2815 ``` 一个long类型是8字节，我们在变量a和b之间不上7个long类型变量呢，输出结果是啥呢？如下： ``` class Rectangle { volatile long a; long a1,a2,a3,a4,a5,a6,a7; volatile long b; } //运行结果执行时间1113 ``` 可以发现利用填充数据的方式，让读写的变量分割到不同缓存行，可以很好挺高性能~ ## 15. Fork/Join框架的理解 Fork/Join框架是Java7提供的一个用于并行执行任务的框架，是一个把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果的框架。 Fork/Join框架需要理解两个点，「分而治之」和「工作窃取算法」。 **分而治之** 以上Fork/Join框架的定义，就是分而治之思想的体现啦 ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/310c275bc0cd40499eb66cf738258e73~tplv-k3u1fbpfcp-zoom-1.image) 工作窃取算法把大任务拆分成小任务，放到不同队列执行，交由不同的线程分别执行时。有的线程优先把自己负责的任务执行完了，其他线程还在慢慢悠悠处理自己的任务，这时候为了充分提高效率，就需要工作盗窃算法啦~ ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/a511d4b1ac2445e592a25fcfc56f887c~tplv-k3u1fbpfcp-zoom-1.image) 工作盗窃算法就是，「某个线程从其他队列中窃取任务进行执行的过程」。一般就是指做得快的线程（盗窃线程）抢慢的线程的任务来做，同时为了减少锁竞争，通常使用双端队列，即快线程和慢线程各在一端。 ## 16. 聊聊ThreadLocal原理？ **ThreadLocal的内存结构图** 为了对```ThreadLocal```有个宏观的认识，我们先来看下```ThreadLocal```的内存结构图 ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/dbf43c994a944c14af1938c84470fec5~tplv-k3u1fbpfcp-zoom-1.image) 从内存结构图，我们可以看到： - ```Thread```类中，有个```ThreadLocal.ThreadLocalMap``` 的成员变量。 - ```ThreadLocalMap```内部维护了```Entry```数组，每个```Entry```代表一个完整的对象，```key```是```ThreadLocal```本身，```value```是```ThreadLocal```的泛型对象值。 **关键源码分析** 对照着关键源码来看，更容易理解一点哈~ 首先看下```Thread```类的源码，可以看到成员变量```ThreadLocalMap```的初始值是为```null``` ``` public class Thread implements Runnable { //ThreadLocal.ThreadLocalMap是Thread的属性 ThreadLocal.ThreadLocalMap threadLocals = null; } ``` 成员变量```ThreadLocalMap```的关键源码如下： ``` static class ThreadLocalMap { static class Entry extends WeakReference> { /** The value associated with this ThreadLocal. */ Object value; Entry(ThreadLocal k, Object v) { super(k); value = v; } } //Entry数组 private Entry[] table; // ThreadLocalMap的构造器，ThreadLocal作为key ThreadLocalMap(ThreadLocal firstKey, Object firstValue) { table = new Entry[INITIAL_CAPACITY]; int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1); table[i] = new Entry(firstKey, firstValue); size = 1; setThreshold(INITIAL_CAPACITY); } } ``` ```ThreadLocal```类中的关键```set()```方法： ``` public void set(T value) { Thread t = Thread.currentThread(); //获取当前线程t ThreadLocalMap map = getMap(t); //根据当前线程获取到ThreadLocalMap if (map != null) //如果获取的ThreadLocalMap对象不为空 map.set(this, value); //K，V设置到ThreadLocalMap中 else createMap(t, value); //创建一个新的ThreadLocalMap } ThreadLocalMap getMap(Thread t) { return t.threadLocals; //返回Thread对象的ThreadLocalMap属性 } void createMap(Thread t, T firstValue) { //调用ThreadLocalMap的构造函数 t.threadLocals = new ThreadLocalMap(this, firstValue); this表示当前类ThreadLocal } ``` ```ThreadLocal```类中的关键```get()```方法 ``` public T get() { Thread t = Thread.currentThread();//获取当前线程t ThreadLocalMap map = getMap(t);//根据当前线程获取到ThreadLocalMap if (map != null) { //如果获取的ThreadLocalMap对象不为空 //由this（即ThreadLoca对象）得到对应的Value，即ThreadLocal的泛型值 ThreadLocalMap.Entry e = map.getEntry(this); if (e != null) { @SuppressWarnings("unchecked") T result = (T)e.value; return result; } } return setInitialValue(); //初始化threadLocals成员变量的值 } private T setInitialValue() { T value = initialValue(); //初始化value的值 Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); //以当前线程为key，获取threadLocals成员变量，它是一个ThreadLocalMap if (map != null) map.set(this, value); //K，V设置到ThreadLocalMap中 else createMap(t, value); //实例化threadLocals成员变量 return value; } ``` 所以怎么回答**ThreadLocal的实现原理**？如下，最好是能结合以上结构图一起说明哈~ - ```Thread```线程类有一个类型为```ThreadLocal.ThreadLocalMap```的实例变量```threadLocals```，即每个线程都有一个属于自己的```ThreadLocalMap```。 - ```ThreadLocalMap```内部维护着```Entry```数组，每个```Entry```代表一个完整的对象，```key```是```ThreadLocal```本身，```value```是```ThreadLocal```的泛型值。 - 并发多线程场景下，每个线程```Thread```，在往```ThreadLocal```里设置值的时候，都是往自己的```ThreadLocalMap```里存，读也是以某个```ThreadLocal```作为引用，在自己的```map```里找对应的```key```，从而可以实现了**线程隔离**。大家可以看下我之前这篇文章哈： [ThreadLocal的八个关键知识点](https://mp.weixin.qq.com/s?__biz=Mzg3NzU5NTIwNg==&mid=2247500784&idx=1&sn=6519d0e092be4ed9d6f4da8d90deef2c&chksm=cf221cd9f85595cf9123043241e92a19ca9c212aa8527cfb2aeb9a2472c6bdab9045cf40f22f&token=311974377&lang=zh_CN#rd) ## 17. TreadLocal为什么会导致内存泄漏呢？ - 弱引用导致的内存泄漏呢？ - key是弱引用，GC回收会影响ThreadLocal的正常工作嘛？ - ThreadLocal内存泄漏的demo ### 17.1 弱引用导致的内存泄漏呢？我们先来看看```TreadLocal```的引用示意图哈： ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ed793222fc65454d8431b68b9abae71b~tplv-k3u1fbpfcp-zoom-1.image) 关于ThreadLocal内存泄漏，网上比较流行的说法是这样的： > ```ThreadLocalMap```使用```ThreadLocal```的**弱引用**作为```key```，当```ThreadLocal```变量被手动设置为```null```，即一个```ThreadLocal```没有外部强引用来引用它，当系统GC时，```ThreadLocal```一定会被回收。这样的话，```ThreadLocalMap```中就会出现```key```为```null```的```Entry```，就没有办法访问这些```key```为```null```的```Entry```的```value```，如果当前线程再迟迟不结束的话(比如线程池的核心线程)，这些```key```为```null```的```Entry```的```value```就会一直存在一条强引用链：Thread变量 -> Thread对象 -> ThreaLocalMap -> Entry -> value -> Object 永远无法回收，造成内存泄漏。当```ThreadLocal```变量被手动设置为```null```后的引用链图： ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/15753a2ca80d40999106bb2bf8136a19~tplv-k3u1fbpfcp-zoom-1.image) 实际上，```ThreadLocalMap```的设计中已经考虑到这种情况。所以也加上了一些防护措施：即在```ThreadLocal```的```get```,```set```,```remove```方法，都会清除线程```ThreadLocalMap```里所有```key```为```null```的```value```。源代码中，是有体现的，如```ThreadLocalMap```的```set```方法： ``` private void set(ThreadLocal key, Object value) { Entry[] tab = table; int len = tab.length; int i = key.threadLocalHashCode & (len-1); for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) { ThreadLocal k = e.get(); if (k == key) { e.value = value; return; } //如果k等于null,则说明该索引位之前放的key(threadLocal对象)被回收了,这通常是因为外部将threadLocal变量置为null, //又因为entry对threadLocal持有的是弱引用,一轮GC过后,对象被回收。 //这种情况下,既然用户代码都已经将threadLocal置为null,那么也就没打算再通过该对象作为key去取到之前放入threadLocalMap的value, 因此ThreadLocalMap中会直接替换调这种不新鲜的entry。 if (k == null) { replaceStaleEntry(key, value, i); return; } } tab[i] = new Entry(key, value); int sz = ++size; //触发一次Log2(N)复杂度的扫描,目的是清除过期Entry if (!cleanSomeSlots(i, sz) && sz >= threshold) rehash(); } ``` 如ThreadLocal的```get```方法： ``` public T get() { Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) { //去ThreadLocalMap获取Entry，方法里面有key==null的清除逻辑 ThreadLocalMap.Entry e = map.getEntry(this); if (e != null) { @SuppressWarnings("unchecked") T result = (T)e.value; return result; } } return setInitialValue(); } private Entry getEntry(ThreadLocal key) { int i = key.threadLocalHashCode & (table.length - 1); Entry e = table[i]; if (e != null && e.get() == key) return e; else //里面有key==null的清除逻辑 return getEntryAfterMiss(key, i, e); } private Entry getEntryAfterMiss(ThreadLocal key, int i, Entry e) { Entry[] tab = table; int len = tab.length; while (e != null) { ThreadLocal k = e.get(); if (k == key) return e; // Entry的key为null,则表明没有外部引用,且被GC回收,是一个过期Entry if (k == null) expungeStaleEntry(i); //删除过期的Entry else i = nextIndex(i, len); e = tab[i]; } return null; } ``` ### 17.2 key是弱引用，GC回收会影响ThreadLocal的正常工作嘛？有些小伙伴可能有疑问，```ThreadLocal```的```key```既然是**弱引用**.会不会GC贸然把```key```回收掉，进而影响```ThreadLocal```的正常使用？ > - **弱引用**:具有弱引用的对象拥有更短暂的生命周期。如果一个对象只有弱引用存在了，则下次GC**将会回收掉该对象**（不管当前内存空间足够与否）其实不会的，因为有```ThreadLocal变量```引用着它，是不会被GC回收的，除非手动把```ThreadLocal变量设置为null```，我们可以跑个demo来验证一下： ``` public class WeakReferenceTest { public static void main(String[] args) { Object object = new Object(); WeakReference