Java线程池弄清这几个参数你会发现如此简单

本篇文章主要讲解Java线程池的相关实现

一.Java线程池

1.定义:
线程池是事先创建若干个可执行的线程放入一个池(容器)中，需要的时候从池中获取线程不用自行创建，线程使用完毕不需要销毁线程而是放回池中，从而减少创建和销毁线程对象的开销。

2.作用:
创建和销毁线程是很费时间的,线程池技术正是关注如何缩短或调整创建和销毁线程时间的技术，从而提高服务器程序性能的。

1).降低资源消耗:重用存在的线程,减少对象创建销毁的开销。

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

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

4).提供定时执行、定期执行、单线程、并发数控制等功能。

3.线程池的组成
1).线程池管理器(ThreadPool):用于创建并管理线程池,包括创建线程池,销毁线程池,添加新任务。

2).工作线程(PoolWorker):线程池中线程,在没有任务时处于等待状态,可以循环的执行任务。

3.任务接口(Task):每个任务必须实现的接口,以供工作线程调度任务的执行,它主要规定了任务的入口,任务执行完后的收尾工作,任务的执行状态等。

4).任务队列(taskQueue):用于存放没有处理的任务,提供一种缓冲机制。

4.线程池的状态
1).RUNNING:运行状态,接受新的任务,处理等待队列中的任务。
2).SHUTDOWN:不接受新的任务提交,但是会继续处理等待队列中的任务。
3).STOP:不接受新的任务提交,不再处理等待队列中的任务,中断正在执行任务的线程。
4).TIDYING:销毁所有任务,线程池的状态在转换为 TIDYING 状态时,会执行方法 terminated()。
5).TERMINATED:执行完terminated()方法后,线程池的状态变为TERMINATED(终止状态)。

二.Java线程池之ThreadPoolExecutor类

ThreadPoolExecutor简介
ThreadPoolExecutor() 是创建线程池最原始的方法,也是阿里巴巴Java开发手册中明确规范的创建线程池的方式。

要了解一个类，需要看这个类的方法，先看下源码:

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;
    }

从它的构造函数可以看出:ThreadPoolExecutor() 中含有几个重要的参数，我们一一分析。

1).corePoolSize ：核心线程池大小，定义了最小可以同时运行的线程数量。默认情况下,在创建了线程池后,线程池中的线程数为0，当有任务来之后,就会创建一个线程去执行任务，如果线程池中的线程数数目少于corePoolSize时，有任务进来就新建一个线程，当线程池中的线程数目达到corePoolSize时,将到达的任务放在缓存队列中。

2).maximumPoolSize ：线程池中允许存在的工作线程的最大数量。队列满后,线程能够达到的最大并发数。

3).workQueue：阻塞队列，当新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，任务就会被存放在队列中。

4).keepAliveTime：当线程池中的线程数量大于 corePoolSize 时，如果这时没有新的任务，核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过了keepAliveTime才会被回收销毁。

5).unit ：keepAliveTime参数的时间单位。

6).threadFactory：为线程池提供创建新线程的线程工厂。

7).handler ：线程池任务队列超过maxinumPoolSize后的拒绝策略。

ThreadPoolExecutor的拒绝策略

如果当前同时运行的线程数量达到最大线程数量并且队列也已经被放满了任务时，ThreadPoolExecutor 提供一些策略:
1).ThreadPoolExecutor.DiscardPolicy：不处理新任务，直接丢弃掉。

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

3).ThreadPoolExecutor.DiscardOldestPolicy：丢弃最早的未处理的任务请求。

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

线程池的实现原理:

解读:
当有新的任务需要处理时:
1).判断当前线程数是否超过核心线程数corePoolSize。
2).如果当前线程数未超过核心线程数corePoolSize则创建一个新线程。
3).如果当前线程数已超过核心线程数corePoolSize则继续判断等待队列workQueue是否已满。
4).如果等待队列未满则先将当前任务放入等待队列workQueue。
5).如果等待队列workQueue已满则判断当前线程池是否已满，即当前线程数量是否超过最大线程数量maximumPoolSize。
6).如果线程池已满则选择相应的拒绝策略进行新任务的处理。

阻塞队列之BlockingQueue
阻塞队列主要的作用是用来存放待执行的任务。常见于生产者-消费者模式。即：
在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的线程会等待队列可用。

生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。

七种阻塞队列
ArrayBlockingQueue ：由数组结构组成的有界阻塞队列(有界队列,基于数组,先进先出)。

LinkedBlockingQueue ：由链表结构组成的无界阻塞队列(无界队列,基于链表,先进先出)。

PriorityBlockingQueue ：支持优先级排序的无界阻塞队列。

DelayQueue：使用优先级队列实现的无界阻塞队列。

SynchronousQueue：不存储元素的阻塞队列。

LinkedTransferQueue：由链表结构组成的无界阻塞队列。

LinkedBlockingDeque：由链表结构组成的双向阻塞队列。

三.实例演示使用ThreadPoolExecutor创建线程池

创建一个线程池,线程池中有6个线程，定义线程池的核心线程为4，最大线程池线程数量为5。

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程执行开始");
        ThreadDelay();
        System.out.println(Thread.currentThread().getName()+"线程执行完毕");
    }
    private void ThreadDelay() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    private static final int CORE_POOL_SIZE = 4;
    private static final int MAX_POOL_SIZE = 5;
    private static final int QUEUE_CAPACITY = 100;
    private static final Long KEEP_ALIVE_TIME = 1L;
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                CORE_POOL_SIZE,
                MAX_POOL_SIZE,
                KEEP_ALIVE_TIME,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(QUEUE_CAPACITY),
                new ThreadPoolExecutor.CallerRunsPolicy());
        for (int i = 0; i < 6; i++) {
            //创建WorkerThread对象（WorkerThread类实现了Runnable 接口）
            Runnable threadpoolexecutor = new ThreadPoolExecutorTest();
            //执行Runnable
            executor.execute(threadpoolexecutor);
        }
        //终止线程池
        executor.shutdown();
        while (!executor.isTerminated()) {
        }
        System.out.println("所有线程执行完毕");
    }
}

结果:

分析:
corePoolSize: 核心线程数为 4。
maximumPoolSize ：最大线程数 5
keepAliveTime : 等待时间为 1L。
unit: 等待时间的单位为 TimeUnit.SECONDS。
workQueue：任务队列为 ArrayBlockingQueue，并且容量为 100;
handler:饱和策略为 CallerRunsPolicy。

从结果可知，线程池的核心线程为4，当前线程为6，超过核心线程数，额外的任务将放到阻塞队列中，拒绝策略为ThreadPoolExecutor.CallerRunsPolicy()，在线程池满时，由调用线程处理该任务，调用执行自己的线程继续运行任务。

执行步骤:
1).线程1~线程4开始执行。
2).线程1~线程4执行结束(不一定按顺序)。
3).超过核心线程数时，继续调用执行自己的线程，额外补充线程执行完，如，额外补充线程1和线程2继续执行，以达到当前需要的总共6个线程。

本篇文章主要简略地介绍了Java线程池的相关技术，希望通过此篇文章能够让大家更加了解线程池的优势、作用以及用法。