《面试题对标大纲》

题目列表集

1、CAS 的会产生什么问题？
2、什么是原子类
3、原子类的常用类
4、说一下 Atomic的原理？
5、死锁与活锁的区别，死锁与饥饿的区别？
6、什么是线程池？
7、线程池作用？
8、线程池有什么优点？
9、什么是ThreadPoolExecutor？
10、什么是Executors？
11、线程池四种创建方式？
12、在 Java 中 Executor 和 Executors 的区别？
13、四种构建线程池的区别及特点？
14、线程池都有哪些状态？
15、线程池中 submit() 和 execute() 方法有什么区别？
16、什么是线程组，为什么在 Java 中不推荐使用？
17、ThreadPoolExecutor饱和策略有哪些？
18、如何自定义线程线程池?
19、线程池的执行原理？
20、如何合理分配线程池大小?

1、CAS 的会产生什么问题？

1、ABA 问题：
比如说一个线程 one 从内存位置 V 中取出 A，这时候另一个线程 two 也从内存中取出 A，并且 two 进
行了一些操作变成了 B，然后 two 又将 V 位置的数据变成 A，这时候线程 one 进行 CAS 操作发现内存
中仍然是 A，然后 one 操作成功。尽管线程 one 的 CAS 操作成功，但可能存在潜藏的问题。从
Java1.5 开始 JDK 的 atomic包里提供了一个类 AtomicStampedReference 来解决 ABA 问题。

2、循环时间长开销大：
对于资源竞争严重（线程冲突严重）的情况，CAS 自旋的概率会比较大，从而浪费更多的 CPU 资源，
效率低于 synchronized。

3、只能保证一个共享变量的原子操作：
当对一个共享变量执行操作时，我们可以使用循环 CAS 的方式来保证原子操作，但是对多个共享变量
操作时，循环 CAS 就无法保证操作的原子性，这个时候就可以用锁。

2、什么是原子类

★ 简单来说就是：原子类来实现CAS无锁模式的算法

• java.util.concurrent.atomic包：是原子类的小工具包，支持在单个变量上解除锁的线程安全编程
  原子变量类相当于一种泛化的 volatile 变量，能够支持原子的和有条件的读-改-写操作。

• 比如：AtomicInteger 表示一个int类型的值，并提供了 get 和 set 方法，这些 Volatile 类型的int
  变量在读取和写入上有着相同的内存语义。它还提供了一个原子的 compareAndSet 方法（如果该
  方法成功执行，那么将实现与读取/写入一个 volatile 变量相同的内存效果），以及原子的添加、
  递增和递减等方法。AtomicInteger 表面上非常像一个扩展的 Counter 类，但在发生竞争的情况
  下能提供更高的可伸缩性，因为它直接利用了硬件对并发的支持。

3、原子类的常用类

AtomicBoolean
AtomicInteger
AtomicLong
AtomicReference

4、说一下 Atomic的原理？

Atomic包中的类基本的特性就是在多线程环境下，当有多个线程同时对单个（包括基本类型及引
用类型）变量进行操作时，具有排他性，即当多个线程同时对该变量的值进行更新时，仅有一个线
程能成功，而未成功的线程可以向自旋锁一样，继续尝试，一直等到执行成功。

5、死锁与活锁的区别，死锁与饥饿的区别？

• 死锁：是指两个或两个以上的线程在执行过程中，因争夺资源而造成的一种互相等待的
  现象，若无外力作用，它们都将无法推进下去。

• 活锁：任务或者执行者没有被阻塞，由于某些条件没有满足，导致一直重复尝试，失败
  ，尝试，失败。

• 活锁和死锁的区别在于，处于活锁的实体是在不断的改变状态，这就是所谓的“活”， 而处于死锁的
  实体表现为等待；活锁有可能自行解开，死锁则不能。

• 饥饿：一个或者多个线程因为种种原因无法获得所需要的资源，导致一直无法执行的状态。
  Java 中导致饥饿的原因：
  1、高优先级线程吞噬所有的低优先级线程的 CPU 时间。
  2、线程被永久堵塞在一个等待进入同步块的状态，因为其他线程总是能在它之前持续地对该
  同步块进行访问。
  3、线程在等待一个本身也处于永久等待完成的对象(比如调用这个对象的 wait 方法)，因为其
  他线程总是被持续地获得唤醒。

6、什么是线程池？

Java中的线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序都可以使用
线程池。在开发过程中，合理地使用线程池能够带来许多好处。

（1）降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
（2）提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
（3）提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降
（4）低系统的稳定性，使用线程池可以进行统一分配、调优和监控。但是，要做到合理利用

7、线程池作用？

• 线程池是为突然大量爆发的线程设计的，通过有限的几个固定线程为大量的操作服务，减少了创建
  和销毁线程所需的时间，从而提高效率。

• 如果一个线程所需要执行的时间非常长的话，就没必要用线程池了(不是不能作长时间操作，而是
  不宜。本来降低线程创建和销毁，结果你那么久我还不好控制还不如直接创建线程)，况且我们还
  不能控制线程池中线程的开始、挂起、和中止。

8、线程池有什么优点？

• 降低资源消耗：重用存在的线程，减少对象创建销毁的开销。

• 提高响应速度。可有效的控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，
  避免堵塞。当任务到达时，任务可以不需要的等到线程创建就能立即执行。

• 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统
  的稳定性，使用线程池可以进行统一的分配，调优和监控。

• 附加功能：提供定时执行、定期执行、单线程、并发数控制等功能。

9、什么是ThreadPoolExecutor？

ThreadPoolExecutor就是线程池

ThreadPoolExecutor其实也是JAVA的一个类，我们一般通过Executors工厂类的方法，通过传入
不同的参数，就可以构造出适用于不同应用场景下的ThreadPoolExecutor（线程池）

image.png

对此构造解读：
corePoolSize 核心线程数量
maximumPoolSize 最大线程数量
keepAliveTime 线程保持时间，N个时间单位
unit 时间单位（比如秒，分）
workQueue 阻塞队列
threadFactory 线程工厂
handler 线程池拒绝策略

10、什么是Executors？

Executors框架实现的就是线程池的功能。

Executors工厂类中提供的newCachedThreadPool、newFixedThreadPool 、
newScheduledThreadPool 、newSingleThreadExecutor 等方法其实也只是
ThreadPoolExecutor的构造函数参数不同而已。通过传入不同的参数，就可以构造出适用于不同
应用场景下的线程池

Executor工厂类如何创建线程池图：

image.png

11、线程池四种创建方式？

Java通过Executors（jdk1.5并发包）提供四种线程池，分别为：

1. newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回
   收空闲线程，若无可回收，则新建线程。

2. newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列
   中等待。

3. newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

4. newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任
   务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

12、在 Java 中 Executor 和 Executors 的区别？

• Executors 工具类的不同方法按照我们的需求创建了不同的线程池，来满足业务的需求。

• Executor 接口对象能执行我们的线程任务。

• ExecutorService 接口继承了 Executor 接口并进行了扩展，提供了更多的方法我们能获得任务执
  行的状态并且可以获取任务的返回值。

• 使用 ThreadPoolExecutor 可以创建自定义线程池。

13、四种构建线程池的区别及特点？

1、newCachedThreadPool

• 特点：newCachedThreadPool创建一个可缓存线程池，如果当前线程池的长度超过了处理的需要
  时，它可以灵活的回收空闲的线程，当需要增加时， 它可以灵活的添加新的线程，而不会对池的
  长度作任何限制

• 缺点：他虽然可以无线的新建线程，但是容易造成堆外内存溢出，因为它的最大值是在初始化的时
  候设置为 Integer.MAX_VALUE，一般来说机器都没那么大内存给它不断使用。当然知道可能出问
  题的点，就可以去重写一个方法限制一下这个最大值

• 总结：线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线
  程，而不用每次新建线程。

package com.kk;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestNewCachedThreadPool {
    public static void main(String[] args) {
        // 创建无限大小线程池，由jvm自动回收 
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool ( );
        for (int i = 0; i < 10; i++) {
            final int temp = i;
            newCachedThreadPool.execute (new Runnable ( ) {
                public void run() {
                    try {
                        Thread.sleep (100);
                    } catch (Exception e) {
                    }
                    System.out.println (Thread.currentThread ( ).getName ( ) + ",i==" + temp);
                }
            });
        }
    }
}

2、newFixedThreadPool

• 特点：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。定长线程池的
  大小最好根据系统资源进行设置。

• 缺点：线程数量是固定的，但是阻塞队列是无界队列。如果有很多请求积压，阻塞队列越来越长，
  容易导致OOM（超出内存空间）

• 总结：请求的挤压一定要和分配的线程池大小匹配，定线程池的大小最好根据系统资源进行设置。
  如Runtime.getRuntime().availableProcessors()

Runtime.getRuntime().availableProcessors()方法是查看电脑CPU核心数量）

package com.kk;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestNewFixedThreadPool {
    public static void main(String[] args) {
        ExecutorService newFixedThreadPool = Executors.newFixedThreadPool (3);
        for (int i = 0; i < 10; i++) {
            final int temp = i;
            newFixedThreadPool.execute (new Runnable ( ) {
                public void run() {

                    System.out.println (Thread.currentThread ( ).getName ( ) + ",i==" + temp);
                }
            });
        }
    }
}

3、newScheduledThreadPool

• 特点：创建一个固定长度的线程池，而且支持定时的以及周期性的任务执行，类似于
  Timer（Timer是Java的一个定时器类）

• 缺点：由于所有任务都是由同一个线程来调度，因此所有任务都是串行执行的，同一时间只能有一
  个任务在执行，前一个任务的延迟或异常都将会影响到之后的任务（比如：一个任务出错，以后的
  任务都无法继续）

package com.lijie;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class TestNewScheduledThreadPool {
    public static void main(String[] args) {
        //定义线程池大小为3 
        ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool (3);
        for (int i = 0; i < 10; i++) {
            final int temp = i;
            newScheduledThreadPool.schedule (new Runnable ( ) {
                public void run() {
                    System.out.println ("i:" + temp);
                }
            }, 3, TimeUnit.SECONDS);//这里表示延迟3秒执行。
        }
    }
}

CSDN博客：Timer定时器用法详解，java原生定时器

4、newSingleThreadExecutor

• 特点：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，如果这个唯一的线程因
  为异常结束，那么会有一个新的线程来替代它，他必须保证前一项任务执行完毕才能执行后一项。
  保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

• 缺点：缺点的话，很明显，他是单线程的，高并发业务下有点无力

• 总结：保证所有任务按照指定顺序执行的，如果这个唯一的线程因为异常结束，那么会有一个新的
  线程来替代它

package com.kk;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestNewSingleThreadExecutor {
    public static void main(String[] args) {
        ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor ( );
        for (int i = 0; i < 10; i++) {
            final int index = i;
            newSingleThreadExecutor.execute (new Runnable ( ) {
                public void run() {
                    System.out.println (Thread.currentThread ( ).getName ( ) + " index:" + index);
                    try {
                        Thread.sleep (200);
                    } catch (Exception e) {
                    }
                }
            });
        }
    }
}

14、线程池都有哪些状态？

• RUNNING：这是最正常的状态，接受新的任务，处理等待队列中的任务。

• SHUTDOWN：不接受新的任务提交，但是会继续处理等待队列中的任务。

• STOP：不接受新的任务提交，不再处理等待队列中的任务，中断正在执行任务的线程。

• TIDYING：所有的任务都销毁了，workCount 为 0，线程池的状态在转换为 TIDYING 状态时，会
  执行钩子方法 terminated()。

• TERMINATED：terminated()方法结束后，线程池的状态就会变成这个。

15、线程池中 submit() 和 execute() 方法有什么区别？

• 相同点：都可以开启线程执行池中的任务。

• 不同点：
  （1）接收参数：execute()只能执行 Runnable 类型的任务。submit()可以执行 Runnable 和
  Callable 类型的任务。
  （2）返回值：submit()方法可以返回持有计算结果的 Future 对象，而execute()没有
  （3）异常处理：submit()方便Exception处理

16、什么是线程组，为什么在 Java 中不推荐使用？

• ThreadGroup 类，可以把线程归属到某一个线程组中，线程组中可以有线程对象，也可以有线程
  组，组中还可以有线程，这样的组织结构有点类似于树的形式。

• T线程组和线程池是两个不同的概念，他们的作用完全不同，前者是为了方便线程的管理，后者是为
  了管理线程的生命周期，复用线程，减少创建销毁线程的开销。

• T为什么不推荐使用线程组？因为使用有很多的安全隐患吧，没有具体追究，如果需要使用，推荐使
  用线程池。

17、ThreadPoolExecutor饱和策略有哪些？

如果当前同时运行的线程数量达到最大线程数量并且队列也已经被放满了任务时，ThreadPoolTaskExecutor 定 义一些策略:

• ThreadPoolExecutor.AbortPolicy：抛出 RejectedExecutionException来拒绝新任务的处理。

• ThreadPoolExecutor.CallerRunsPolicy：调用执行自己的线程运行任务。您不会任务请求。但是
  这种策略会降低对于新任务提交速度，影响程序的整体性能。另外，这个策略喜欢增加队列容量。
  如果您的应用程序可以承受此延迟并且你不能任务丢弃任何一个任务请求的话，你可以选择这个策
  略。

• ThreadPoolExecutor.DiscardPolicy：不处理新任务，直接丢弃掉。

• ThreadPoolExecutor.DiscardOldestPolicy： 此策略将丢弃最早的未处理的任务请求。

18、如何自定义线程线程池?（其实上面的 #9也有重复部分，帮助记忆在放一遍）

• 先看ThreadPoolExecutor（线程池）这个类的构造参数

  
  image.png

构造参数参数介绍：：

corePoolSize 核心线程数量
maximumPoolSize 最大线程数量
keepAliveTime 线程保持时间，N个时间单位
unit 时间单位（比如秒，分）
workQueue 阻塞队列
threadFactory 线程工厂
handler 线程池拒绝策略

package com.kk;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test001 {
    public static void main(String[] args) { //创建线程池

        ThreadPoolExecutor executor = new ThreadPoolExecutor (1, 2, 60L, TimeUnit.SECONDS, new ArrayBlockingQueue<> (3));
        for (int i = 1; i <= 6; i++) {
            TaskThred t1 = new TaskThred ("任务" + i);
            executor.execute (t1);
            //是执行线程方法 
            executor.execute (t1);
        }
        executor.shutdown ( );
        //不再接受新的任务，并且等待之前提交的任务都执行完再关 闭，阻塞队列中的任务不会再执行。 
        executor.shutdown ( );
    }
}

class TaskThred implements Runnable {
    private String taskName;

    public TaskThred(String taskName) {
        this.taskName = taskName;
    }

    public void run() {
        System.out.println (Thread.currentThread ( ).getName ( ) + taskName);
    }
}

19、线程池的执行原理？

image.png

• 提交一个任务到线程池中，线程池的处理流程如下：
  （1）判断线程池里的核心线程是否都在执行任务，如果不是（核心线程空闲或者还有核心线程没
  有被创建）则创建一个新的工作线程来执行任务。如果核心线程都在执行任务，则进入下个
  流程。
  （2）线程池判断工作队列是否已满，如果工作队列没有满，则将新提交的任务存储在这个工作队
  列里。如果工作队列满了，则进入下个流程。
  （3）判断线程池里的线程是否都处于工作状态，如果没有，则创建一个新的工作线程来执行任
  务。如果已经满了，则交给饱和策略来处理这个任务。

20、如何合理分配线程池大小?

• 要合理的分配线程池的大小要根据实际情况来定，简单的来说的话就是根据CPU密集和IO密集来
  分配

一、什么是CPU密集

• CPU密集的意思是该任务需要大量的运算，而没有阻塞，CPU一直全速运行。

• CPU密集任务只有在真正的多核CPU上才可能得到加速(通过多线程)，而在单核CPU上，无论你开
  几个模拟的多线程，该任务都不可能得到加速，因为CPU总的运算能力就那样。

二、什么是IO密集

• IO密集型，即该任务需要大量的IO，即大量的阻塞。在单线程上运行IO密集型的任务会导致浪费
  大量的CPU运算能力浪费在等待。所以在IO密集型任务中使用多线程可以大大的加速程序运行，
  即时在单核CPU上，这种加速主要就是利用了被浪费掉的阻塞时间。

三、分配CPU和IO密集

1. CPU密集型时，任务可以少配置线程数，大概和机器的cpu核数相当，这样可以使得每个线程都在
   执行任务

2. IO密集型时，大部分线程都阻塞，故需要多配置线程数，2*cpu核数

四、从以下几个角度分析任务的特性：

任务的性质：CPU密集型任务、IO密集型任务、混合型任务。
任务的优先级：高、中、低。
任务的执行时间：长、中、短。
任务的依赖性：是否依赖其他系统资源，如数据库连接等。

五、结论

线程等待时间比CPU执行时间比例越高，需要越多线程。
线程CPU执行时间比等待时间比例越高，需要越少线程。