一文弄懂Java中的线程池

一、线程

线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。
在java中可以通过两种方式创建线程：

• 继承Thread类创建线程。
• 实现Runnable接口创建线程。Java不支持类的多重继承，但允许你调用多个接口。所以如果你要继承其他类，当然是调用Runnable接口好了。
• 使用Callable和Future创建线程。（jdk1.5开始提供）

java.lang.Thread 类的实例就是一个线程但是它需要调用java.lang.Runnable接口来执行，由于线程类本身就是调用的Runnable接口所以你可以继承java.lang.Thread 类或者直接调用Runnable接口来重写run()方法实现线程。和Runnable接口不一样，Callable接口提供了一个call()方法作为线程执行体，call()方法比run()方法功能要强大，call()方法可以有返回值并且可以抛出异常。运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。

// 继承Thread类创建线程
 public class MyThread extends Thread{       
   public void run(){
      System.out.println(" Thread Running " + Thread.currentThread().getName());
   }
 }
// 实现Runnable接口创建线程
public class MyRunnable implements Runnable{         
    public void run(){
       System.out.println(" Create Thread " + Thread.currentThread().getName());
    }
 }

// 实现Callable接口创建线程
class MyCallable implements Callable {
    public String call() throws Exception {
         return Thread.currentThread().getName();
    }
}

//starting Thread in Java
Thread mythread = new MyThread(); //Thread created not started
mythread.setName("T1");
mythread.start(); 

Thread myrunnable = new Thread(new MyRunnable(),"T2"); //Thread created       
myrunnable.start();

MyCallable td = newMyCallable();
FutureTask result = new FutureTask<>(td);
Thread myCallable = new Thread(result);
myCallable.start();

参考：
https://javarevisited.blogspot.com/2011/02/how-to-implement-thread-in-java.html
https://www.cnblogs.com/3s540/p/7172146.html

二、线程池

• Executor：一个接口，其定义了一个接收Runnable对象的方法executor，其方法签名为executor(Runnable command)
• ExecutorService：是一个比Executor使用更广泛的子类接口，其提供了生命周期管理的方法，以及可跟踪一个或多个异步任务执行状况返回Future的方法
• AbstractExecutorService：ExecutorService执行方法的默认实现
• ScheduledExecutorService：一个可定时调度任务的接口
• ScheduledThreadPoolExecutor：ScheduledExecutorService的实现，一个可定时调度任务的线程池
• ThreadPoolExecutor：表示一个线程池，可以通过调用Executors的静态工厂方法来创建一个拥有特定功能的线程池并返回一个ExecutorService对象

以上成员均在 java.util.concurrent包中, 是 JDK并发包的核心类。其中ThreadpoolExecutor表示一个线程池。 Executors类则扮演着线程池工厂的角色,通过 Executors可以取得一个拥特定功能的线程池。从 UML图中亦可知, ThreadPoolExecutor类实现了 Executor接口, 因此通过这个接口, 任何 Runnable的对象都可以被 ThreadPoolExecutor线程池调度。

1、ThreadPoolExecutor

ThreadPoolExecutor提供了四个构造函数：

//五个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue workQueue)
//六个参数的构造函数-1
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue workQueue,
                          ThreadFactory threadFactory)
//六个参数的构造函数-2
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue workQueue,
                          RejectedExecutionHandler handler)
//七个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

详细参数解释（可以对照上图线程图原理图）：

• corePoolSize。该线程池中核心线程数最大值
• maximumPoolSize。该线程池中线程总数最大值，线程总数 = 核心线程数 + 非核心线程数。
• keepAliveTime。该线程池中非核心线程闲置超时时长，一个非核心线程，如果不干活(闲置状态)的时长超过这个参数所设定的时长，就会被销毁掉，如果设置allowCoreThreadTimeOut = true，则会作用于核心线程
• unit。keepAliveTime的单位，TimeUnit是一个枚举类型，其包括：

TimeUnit.DAYS; //天
TimeUnit.HOURS; //小时
TimeUnit.MINUTES; //分钟
TimeUnit.SECONDS; //秒
TimeUnit.MILLISECONDS; //毫秒
TimeUnit.MICROSECONDS; //微妙
TimeUnit.NANOSECONDS; //纳秒

• workQueue。该线程池中的任务队列：维护着等待执行的Runnable对象。常用类型包含：

1.SynchronousQueue：这个队列接收到任务的时候，会直接提交给线程处理，而不保留它，如果所有线程都在工作怎么办？那就新建一个线程来处理这个任务！所以为了保证不出现<线程数达到了maximumPoolSize而不能新建线程>的错误，使用这个类型队列的时候，maximumPoolSize一般指定成Integer.MAX_VALUE，即无限大
2.LinkedBlockingQueue：这个队列接收到任务的时候，如果当前线程数小于核心线程数，则新建线程(核心线程)处理任务；如果当前线程数等于核心线程数，则进入队列等待。由于这个队列没有最大值限制，即所有超过核心线程数的任务都将被添加到队列中，这也就导致了maximumPoolSize的设定失效，因为总线程数永远不会超过corePoolSize
3.ArrayBlockingQueue：可以限定队列的长度，接收到任务的时候，如果没有达到corePoolSize的值，则新建线程(核心线程)执行任务，如果达到了，则入队等候，如果队列已满，则新建线程(非核心线程)执行任务，又如果总线程数到了maximumPoolSize，并且队列也满了，则发生错误
4.DelayQueue：队列内元素必须实现Delayed接口，这就意味着你传进去的任务必须先实现Delayed接口。这个队列接收到任务时，首先先入队，只有达到了指定的延时时间，才会执行任务

• threadFactory。线程工厂，主要用来创建线程。
• handler：表示当拒绝处理任务时的策略，有以下四种取值：

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

参考：
Java并发编程：线程池的使用：https://www.cnblogs.com/dolphin0520/p/3932921.html
线程池，这一篇或许就够了：https://www.jianshu.com/p/210eab345423
线程池的使用(线程池重点解析)：https://www.cnblogs.com/zzuli/p/9386463.html

2、ForkJoinPool

ForkJoinPool运用了Fork/Join原理，使用“分而治之”的思想，将大任务分拆成小任务分配给多个线程执行，最后合并得到最终结果，加快运算。

ForkJoinPool里有三个重要的角色：
ForkJoinWorkerThread（下文简称worker）：包装Thread；
WorkQueue：任务队列，双向；
ForkJoinTask：worker执行的对象，实现了Future。两种类型，一种叫submission，另一种就叫task。

参考：
线程池篇（五）：ForkJoinPool - 1：https://www.jianshu.com/p/de025df55363
线程池篇（五）：ForkJoinPool - 2：https://www.jianshu.com/p/6a14d0b54b8d
如何使用 ForkJoinPool 以及原理：http://blog.dyngr.com/blog/2016/09/15/java-forkjoinpool-internals/

三、Java通过Executors提供的线程池

Java通过Executors提供五种线程池，分别为：

• newCachedThreadPool：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
• newFixedThreadPool：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
• newScheduledThreadPool：创建一个定长线程池，支持定时及周期性任务执行。
• newSingleThreadExecutor：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
• newWorkStealingPool：jdk1.8新增，创建持有足够线程的线程池来支持给定的并行级别，并通过使用多个队列，减少竞争，它需要穿一个并行级别的参数，如果不传，则被设定为默认的CPU数量。（实质是使用ForkJoinPool实现）

示例：

ExecutorService service = Executors.newFixedThreadPool(5);
Future future = service.submit(()->{
    try{
        Thread.sleep(5000);
    }catch (Exception e){
        e.printStackTrace();
    }
    return 1;
});
System.out.println(future.get().toString());

参考：
http://www.cnblogs.com/webglcn/p/5265901.html

四、Spring中线程池

Spring框架提供了线程池和定时任务执行的抽象接口：TaskExecutor和TaskScheduler来支持异步执行任务和定时执行任务功能。

• TaskExecutor：

Spring的TaskExecutor接口与java.util.concurrent.Executor接口相同。该接口具有单个方法(execute(Runnable task))，该方法根据线程池的语义和配置接受要执行的任务。

实现类名	对应解释
SyncTaskExecutor	该实现类不会执行异步调用。 相反，每次调用都在调用的线程中进行(翻译过来也即同步任务执行器)。 它主要用于不需要多线程的情况，例如在简单的测试用例中。
SimpleAsyncTaskExecutor	此实现不会重用任何线程。 相反，它为每次调用启动一个新线程。 但是，它确实支持并发限制，该限制会阻止超出限制的任何调用，直到释放插槽为止。(说简单了，就是要使用了直接创建一个线程)
ConcurrentTaskExecutor	此实现是java.util.concurrent.Executor实例的适配器。很少需要直接使用ConcurrentTaskExecutor(官网自己都觉得很少使用，不过相对于ThreadPoolTaskExecutor，官网推荐如果ThreadPoolTaskExecutor不够灵活，无法满足需求，则可以使用ConcurrentTaskExecutor)。
ThreadPoolTaskExecutor	杀手锏级的任务调度器(最常用)，可以说已经足够满足我们的需求了(除非,非常非常特例才使用ConcurrentTaskExecutor)。官网翻译重要片段:公开了bean属性，用于配置java.util.concurrent.ThreadPoolExecutor并将其包装在TaskExecutor中
WorkManagerTaskExecutor	此实现使用CommonJ WorkManager作为其后备服务提供程序，并且是在Spring应用程序上下文中在WebLogic或WebSphere上设置基于CommonJ的线程池集成的中心便利类。
DefaultManagedTaskExecutor	此实现在JSR-236兼容的运行时环境（例如Java EE 7+应用程序服务器）中使用JNDI获取的ManagedExecutorService，为此目的替换CommonJ WorkManager。(说明了就是依赖环境)

• TaskScheduler：

用于在将来的某个时间点调度任务。

TaskScheduler接口是定时器的抽象，它的源代码如下。可以看到，该接口包含了一组方法用于指定任务执行的时间。

注：自带的Scheduled，可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多，本文主要介绍。

public interface TaskScheduler {

    //指定一个具体时间点执行定时任务，可以动态的指定时间，开启任务。只执行一次。
    ScheduledFuture schedule(Runnable task, Trigger trigger);

    ScheduledFuture schedule(Runnable task, Date startTime);

    //指定时间开始执行，循环任务，指定一个间隔周期（毫秒计时）注：不管上一个周期是否执行完，到时间下个周期就开始执行

    ScheduledFuture scheduleAtFixedRate(Runnable task, Date startTime, long period);

    //立即执行，循环任务，指定一个执行周期（毫秒计时） 注：不管上一个周期是否执行完，到时间下个周期就开始执行
    ScheduledFuture scheduleAtFixedRate(Runnable task, long period);

    //指定时间开始执行，循环任务，指定一个间隔周期（毫秒计时）注：上一个周期执行完，等待delay时间，下个周期开始执行
    ScheduledFuture scheduleWithFixedDelay(Runnable task, Date startTime, long delay);

    //立即执行，循环任务，指定一个间隔周期（毫秒计时）注：上一个周期执行完，等待delay时间，下个周期开始执行
    ScheduledFuture scheduleWithFixedDelay(Runnable task, long delay);
}

实现类名	对应解释
ConcurrentTaskScheduler	该类实际继承了ConcurrentTaskExecutor对象。只是实现了TaskScheduler接口，增加了相关定时调度任务的方法。
ThreadPoolTaskScheduler	spring对该类设计原则同ThreadPoolTaskExecutor类。是为了定时调度任务不依赖相关的运行容器(例如weblogic、WebSphere等)。其底层委托给ScheduledExecutorService，向外暴露相关的常见bean配置属性。TaskScheduler接口的默认实现类，可以设置执行线程池数（默认一个线程）。

参考：
https://www.jianshu.com/p/ad7bf4472453

1、ThreadPoolTaskExecutor

其实质还是内部封装ThreadPoolExecutor类。

XML配置

注解配置

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.TaskExecutor;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.ThreadPoolExecutor;
@Configuration
@EnableAsync
public class ThreadPoolConfig {
    @Bean(name = "taskExecutor")
    public TaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 设置核心线程数
        executor.setCorePoolSize(1 << 2);
        // 设置最大线程数
        executor.setMaxPoolSize(1 << 3);
        // 设置队列容量
        executor.setQueueCapacity(1 << 3);
        // 设置线程活跃时间（秒）
        executor.setKeepAliveSeconds(60);
        // 设置默认线程名称
        executor.setThreadNamePrefix("task-");
        // 设置拒绝策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 等待所有任务结束后再关闭线程池
        executor.setWaitForTasksToCompleteOnShutdown(true);
        return executor;
    }
}

使用示例：

@Service
public class TestThreadPool {
    @Resource
    private TaskExecutor taskExecutor;
    public void test(){
        taskExecutor.execute(() -> {
            //todo something
        });

        //或

       taskExecutor.execute(new Runnable() {
            public void run() {
                 // todo something
            }
        });
    }
}

2、ThreadPoolTaskScheduler

这种scheduler机制是task的默认机制，而且从名字上也可以看到它是一种委托到ThreadPool的机制，每个 调度任务 都会分配到 线程池 中的一个 线程 去执行。也就是说，任务是 并发执行，互不影响的。可以将它看成一个 轻量级 的 Quartz，而且使用起来比 Quartz 简单许多，但是适用于 单节点的定时任务调度。

ThreadPoolTaskScheduler是TaskScheduler接口的默认实现类，多线程定时任务执行。可以设置执行线程池数（默认一个线程）。在spring-bean.xml中进行配置
使用task:scheduler标签时，spring会实例化一个ThreadPoolTaskScheduler。

XML配置

@Lazy
@Service
public class DemoTask {
    public void job1() {
        System.out.println("Task job1: " + System.currentTimeMillis());
    }
    public void job2() {
        System.out.println("Task job2: " + System.currentTimeMillis());
    }
}

XML 的配置，定义一个 scheduler，然后定义具体任务 scheduled-task。
1、task:scheduler 定义一个 ThreadPoolTaskScheduler, 提供唯一参数指定了池大小。

• pool-size: 任务池大小。池的大小控制着 task:scheduled 的执行，例如以上例子，若 pool-size = 1，则两个 task 只能依次运行，无法并行执行。

2、task:scheduled-tasks ：指定所采用的任务池

• scheduler: 定义的任务池 Bean 的 ID，若不指定，则会被包装为一个单线程 Executor
• task:scheduled : 指定具体任务，至少有一个，其参数如下表

参数名	说明
initial-delay	任务初始延迟，单位 milliseconds
fixed-delay	任务固定间隔时间，时间自前一次完成后计算，单位 milliseconds
fixed-rate	任务固定间隔时间，时间自前一次开始后计算，单位 milliseconds
cron	cron 表达式
trigger	实现 Trigger 接口的 Bean 的引用
ref	具体 Task 的方法所在类
method	具体 Task 的方法名

注解配置

使用@Scheduler注解先要使用task:annotation-driven启动注解开关。

@Service
public class DemoTask {
    @Scheduled(cron = "5 * * * * ?")
    public void job1() {
        System.out.println("Task job1: " + System.currentTimeMillis());
    }
    @Scheduled(initialDelay = 100, fixedDelay = 1000)
    public void job2() {
        System.out.println("Task job2: " + System.currentTimeMillis());
    }
}

五、监听Future任务结果的解决方案

1、Guava中ListenableFuture实现

ListenableFuture是对原有Future的增强，可以用于监听Future任务的执行状况，是执行成功还是执行失败，并提供响应的接口用于对不同结果的处理。

(1)对任务添加回调函数

public class ListenFutureTest {
    public static void main(String[] args) {
        testListenFuture();
    }

    public static void testListenFuture() {
        System.out.println("主任务执行完，开始异步执行副任务1.....");
        ListeningExecutorService pool = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(5));
        ListenableFuture future = pool.submit(new Task());
        Futures.addCallback(future, new FutureCallback() {
            @Override
            public void onSuccess(String result) {
                System.out.println("成功,结果是:" + result);
            }

            @Override
            public void onFailure(Throwable t) {
                System.out.println("出错,业务回滚或补偿");
            }
        });
        System.out.println("副本任务启动,回归主任务线，主业务正常返回2.....");
    }
}
class Task implements Callable {

    @Override
    public String call() throws Exception {
        TimeUnit.SECONDS.sleep(1);
       // int a =1/0;
        return "task done";
    }
}

(2) 等待获得所有任务执行结果

通过Guava中Futures类中allAsList和successfulAsList阻塞获得所有线程的执行结果。

• allAsList：对多个ListenableFuture的合并，返回一个当所有Future成功时返回多个Future返回值组成的List对象。

注：当其中一个Future发生异常时候，将程序报错。

• successfulAsList：和allAsList相似，唯一差别是对于失败或取消的Future返回值用null代替。

ListeningExecutorService pool = MoreExecutors.newDirectExecutorService();
ListenableFuture future1 = pool.submit(() -> "Hello");
ListenableFuture future2 = pool.submit(() -> 2);
ListenableFuture> future = Futures.allAsList(future1, future2);
List