全面解析java线程池

什么是线程池

程序运行的本质是cpu进程的调度（占用系统的资源）进程是一个动态的过程，是一个活动的实体。简单来说，一个应用程序的运行就可以被看做是一个进程，而线程，是运行中的实际的任务执行者。可以说，进程中包含了多个可以同时运行的线程。而在Java中，内存资源是极其宝贵的，所以，我们就提出了线程池的概念。

线程池：Java中开辟出了一种管理线程的概念，这个概念叫做线程池，使用池的技术可以降低资源消耗（常见的池技术有jdbc连接池，线程池，内存池，对象池）。线程池的优点有：

（1）降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

（2）提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。

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

线程的六种状态

NEW：
可运行线程的线程状态。一个处于可运行状态的线程正在Java虚拟机中执行，但它可能正在等待来自操作系统(如处理器)的其他资源。

RUNNABLE：
等待监视器锁而阻塞的线程的线程状态。处于阻塞状态的线程正在等待监视器锁进入一个同步的块/方法，或者在调用之后重新进入一个同步的块/方法。

BLOCKED：
处于等待状态的线程正在等待另一个线程执行特定的操作。例如，在一个对象上调用了object. wait()的线程正在等待另一个线程在该对象上调用object. notify()或object. notifyall()。调用thread .join()的线程正在等待指定的线程终止。

WAITING：
具有指定等待时间的等待线程的线程状态。由于调用了下列方法中的一个，并且指定了正等待时间，线程处于定时等待状态:

Thread.sleep
Object.wait with timeout
Thread.join with timeout
LockSupport.parkNanos
LockSupport.parkUntil

TIMED_WAITING：
终止线程的线程状态。线程已经完成执行。

TERMINATED：
线程终止状态线程被销毁。

四种常见线程池

Executors.newSingleThreadExecutor();//单一线程创建一个线程执行任务

 ExecutorService threadPool = Executors.newSingleThreadExecutor();//单一线程
        for (int i = 1; i <= 5; i++) {
     
            threadPool.execute(()->{
     
                System.out.println(Thread.currentThread().getName());
            });
        }
运行结果：
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1

特点：只有 1 个核心线程，无非核心线程，执行完立即回收，任务队列为链表结构的有界队列。

应用场景：不适合并发但可能引起 IO 阻塞性及影响 UI 线程响应的操作，如数据库操作、文件操作等。

Executors.newFixedThreadPool(5);//创建一个固定数量的线程池执行任务

ExecutorService executorService = Executors.newFixedThreadPool(5);
 for (int i = 1; i <= 5; i++) {
     
            executorService.execute(()->{
     
                System.out.println(Thread.currentThread().getName());
            });
        }
        //关闭线程池
        executorService.shutdown();
执行结果：
pool-1-thread-1
pool-1-thread-4
pool-1-thread-3
pool-1-thread-2
pool-1-thread-5

特点：定长的线程池，有核心线程，核心线程的即为最大的线程数量，没有非核心线程。

应用场景：控制线程最大并发数。

Executors.newCachedThreadPool();//遇强则强遇弱则弱

 ExecutorService executor = Executors.newCachedThreadPool();
for (int i = 1; i <= 10; i++) {
     
            executor.execute(()->{
     
                System.out.println(Thread.currentThread().getName());
            });
        }
        //关闭线程池
        executor.shutdown();
测试结果：
pool-1-thread-1
pool-1-thread-2
pool-1-thread-5
pool-1-thread-4
pool-1-thread-3
pool-1-thread-6
pool-1-thread-9
pool-1-thread-7
pool-1-thread-8
pool-1-thread-10

特点：可缓存的线程池，该线程池中没有核心线程，非核心线程的数量为Integer.max_value，就是无限大，当有需要时创建线程来执行任务，没有需要时回收线程。

应用场景：适用于耗时少，任务量大的情况。

Executors.newScheduledThreadPool

public class demo6 {
     
    public static void main(String[] args) {
     
       ExecutorService executor = Executors.newScheduledThreadPool(3);
        for (int i = 1; i <= 9; i++) {
     
            executor.execute(()->{
     
                System.out.println(Thread.currentThread().getName());
            });
        }
        //关闭线程池
        executor.shutdown();
        //Thread.State
    }
}

周期性执行任务的线程池，按照某种特定的计划执行线程中的任务，有核心线程，但也有非核心线程，非核心线程的大小也为无限大。适用于执行周期性的任务。

四种线程池对比

线程池的七大参数

下面我们来分析一下源代码Executors其实是一个线程池的工具类真正创建线程池的还是ThreadPoolExecutor类下面我们来看看ThreadPoolExecutor类的构造方法：

 public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
     
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

 public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
     
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }

 public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
     
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }

 public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
     
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

从源码中我们发现了构造方法中一共有七个参数

1. corePoolSize（必需）：核心线程数。默认情况下，核心线程会一直存活，但是当将 allowCoreThreadTimeout 设置为 true 时，核心线程也会超时回收。

2. maximumPoolSize（必需）：线程池所能容纳的最大线程数。当活跃线
   程数达到该数值后，后续的新任务将会阻塞。

3.keepAliveTime（必需）：线程闲置超时时长。如果超过该时长，非核心线程就会被回收。如果将allowCoreThreadTimeout 设置为 true 时，核心线程也会超时回收。

4.unit（必需）：指定keepAliveTime 参数的时间单位。常用的有：TimeUnit.MILLISECONDS（毫秒）、TimeUnit.SECONDS（秒）、TimeUnit.MINUTES（分）。

5.workQueue（必需）：任务队列。通过线程池的 execute() 方法提交的 Runnable 对象将存储在该参数中。其采用阻塞队列实现。

任务队列是基于阻塞队列实现的，即采用生产者消费者模式，在 Java 中需要实现 BlockingQueue 接口。

ArrayBlockingQueue：一个由数组结构组成的有界阻塞队列（数组结构可配合指针实现一个环形队列）。

LinkedBlockingQueue： 一个由链表结构组成的有界阻塞队列，在未指明容量时，容量默认为 Integer.MAX_VALUE。

PriorityBlockingQueue： 一个支持优先级排序的无界阻塞队列，对元素没有要求，可以实现 Comparable 接口也可以提供 Comparator 来对队列中的元素进行比较。跟时间没有任何关系，仅仅是按照优先级取任务。

DelayQueue：类似于PriorityBlockingQueue，是二叉堆实现的无界优先级阻塞队列。要求元素都实现 Delayed 接口，通过执行时延从队列中提取任务，时间没到任务取不出来。

SynchronousQueue： 一个不存储元素的阻塞队列，消费者线程调用 take() 方法的时候就会发生阻塞，直到有一个生产者线程生产了一个元素，消费者线程就可以拿到这个元素并返回；生产者线程调用 put() 方法的时候也会发生阻塞，直到有一个消费者线程消费了一个元素，生产者才会返回。

LinkedBlockingDeque： 使用双向队列实现的有界双端阻塞队列。双端意味着可以像普通队列一样 FIFO（先进先出），也可以像栈一样 FILO（先进后出）。

LinkedTransferQueue： 它是ConcurrentLinkedQueue、LinkedBlockingQueue 和 SynchronousQueue 的结合体，但是把它用在 ThreadPoolExecutor 中，和 LinkedBlockingQueue 行为一致，但是是无界的阻塞队列。

注意有界队列和无界队列的区别：如果使用有界队列，当队列饱和时并超过最大线程数时就会执行拒绝策略；而如果使用无界队列，因为任务队列永远都可以添加任务，所以设置 maximumPoolSize 没有任何意义。

6.threadFactory（可选）：线程工厂。用于指定为线程池创建新线程的方式。

7.handler（可选）：拒绝策略。当达到最大线程数时需要执行的饱和策略。拒绝策略我们在下面讲

下面依靠一张图来更好的理解线程池和这几个参数

由图，我们可以看出，线程池中的corePoolSize就是线程池中的核心线程数量，这几个核心线程，就算在没有用的时候，也不会被回收，maximumPoolSize就是线程池中可以容纳的最大线程的数量，而keepAliveTime，就是线程池中除了核心线程之外的其他的最长可以保留的时间，因为在线程池中，除了核心线程即使在无任务的情况下也不能被清除，其余的都是有存活时间的，意思就是非核心线程可以保留的最长的空闲时间，而unit，就是计算这个时间的一个单位，workQueue，就是等待队列，任务可以储存在任务队列中等待被执行，执行的是FIFIO原则（先进先出）。threadFactory，就是创建线程的线程工厂，最后一个handler,是一种拒绝策略，我们可以在任务满了之后，拒绝执行某些任务。

线程池的处理流程

四种拒绝策略

当线程池的线程数达到最大线程数时，需要执行拒绝策略。拒绝策略需要实现 RejectedExecutionHandler 接口，并实现 rejectedExecution(Runnable r, ThreadPoolExecutor executor) 方法。不过 Executors 框架已经为我们实现了 4 种拒绝策略：

AbortPolicy（默认）：丢弃任务并抛出 RejectedExecutionException 异常。

public class demo2 {
     
    public static void main(String[] args) {
     
        //创建一个核心线程为2，最大容量线程为5线程闲置超时时长为3秒，采取拒绝策略的线程池
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(2, 5, 3, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(3), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        //最大承载=最大容量线程+队列数量=8
        //9>8超过最大承重量报RejectedExecutionException
        for (int i = 0; i < 9; i++) {
     
           poolExecutor.execute(()->{
     
                System.out.println(Thread.currentThread().getName());
            });
        }

    }
}
测试结果：
pool-1-thread-1
pool-1-thread-3
pool-1-thread-2
pool-1-thread-4
pool-1-thread-3
pool-1-thread-1
pool-1-thread-5
pool-1-thread-2
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task threadpool.demo2$$Lambda$14/0x0000000100066840@71be98f5 rejected from java.util.concurrent.ThreadPoolExecutor@6fadae5d[Running, pool size = 5, active threads = 5, queued tasks = 0, completed tasks = 3]
	at java.base/java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2055)
	at java.base/java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:825)
	at java.base/java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1355)
	at threadpool.demo2.main(demo2.java:16)

CallerRunsPolicy：由调用线程处理该任务。

public class demo3 {
     
    public static void main(String[] args) {
     
        //创建一个核心线程为2，最大容量线程为5线程闲置超时时长为3秒
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(2, 5, 3, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(3), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy());
        //最大承载=最大容量线程+队列数量
        //超过报RejectedExecutionException
        for (int i = 0; i < 9; i++) {
     
           poolExecutor.execute(()->{
     
                System.out.println(Thread.currentThread().getName());
            });
        }

    }
}
超过了由主线程来处理

pool-1-thread-1
pool-1-thread-3
main
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
pool-1-thread-2
pool-1-thread-4
pool-1-thread-5

DiscardPolicy：丢弃任务，但是不抛出异常。可以配合这种模式进行自定义的处理方式。

public class demo4 {
     
    public static void main(String[] args) {
     
        //创建一个核心线程为2，最大容量线程为5线程闲置超时时长为3秒
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(2, 5, 3, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(3), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardPolicy());
        //最大承载=最大容量线程+队列数量
        //超过报RejectedExecutionException
        for (int i = 0; i < 9; i++) {
     
           poolExecutor.execute(()->{
     
                System.out.println(Thread.currentThread().getName());
            });
        }

    }
}
丢掉了一个任务

pool-1-thread-1
pool-1-thread-3
pool-1-thread-2
pool-1-thread-4
pool-1-thread-3
pool-1-thread-1
pool-1-thread-5
pool-1-thread-2

DiscardOldestPolicy：丢弃队列最早的未处理任务，然后重新尝试执行任务。优化版

public class demo5 {
     
    public static void main(String[] args) {
     
        //创建一个核心线程为2，最大容量线程为5线程闲置超时时长为3秒，采取拒绝策略的线程池
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(2, 5, 3, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(3), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy());
        //最大承载=最大容量线程+队列数量
        //超过报RejectedExecutionException
        for (int i = 0; i < 12; i++) {
     
           poolExecutor.execute(()->{
     
                System.out.println(Thread.currentThread().getName());
            });
        }

    }
}
pool-1-thread-1
pool-1-thread-3
pool-1-thread-3
pool-1-thread-3
pool-1-thread-2
pool-1-thread-1
pool-1-thread-4
pool-1-thread-5

总结

Executors 的 4 个功能线程池虽然方便，但现在已经不建议使用了，而是建议直接通过使用 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

其中 Executors 的功能线程有如下弊端：

FixedThreadPool 和 SingleThreadExecutor：主要问题是堆积的请求处理队列均采用 LinkedBlockingQueue，可能会耗费非常大的内存，甚至 OOM。
CachedThreadPool：主要问题是线程数最大数是Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至 OOM。