Java线程池

1.简介

为了避免系统频繁地创建和销毁线程，我们可以进行线程复用，用来节省资源。
线程池的结构：

Executor: 根接口
 - ExecutorService: 接口，线程池的主要接口；
     - ThreadPoolExecutor: 类，表示一个线程池，继承了AbstractExecutorService抽象类；
     - ScheduledExecutorService：接口，可以以一定周期对线程进行调度；
         -ScheduledThreadPoolExecutor: 类，也表示一个线程池，而且对ThreadPoolExecutor类的功能进行了扩展（继承
            了该类），并实现了ScheduledExecutorService接口；
Executors: 类，扮演线程池工厂的角色（即由它来生产线程池）；

2.线程池

工厂方法的具体说明如下：
- newFixedThreadPool(): 该方法返回一个固定线程数量的线程池，该线程池中的线程数量不变。当有一个新任务提交时，线程池中若有空闲线程，则立即执行；若没有，则任务会被放入一个任务队列中，待有线程空闲时，便处理在任务队列中的任务。
- newSingleThreadExecutor(): 该方法返回一个只有一个线程的线程池。当有多余一个任务被提交，任务会被放入一个任务队列中，按照先入先出的顺序处理在任务队列中的任务。
- newCachedThreadPool(): 线程池的数量不固定，如有空闲线程可复用，则优先使用；若没有空闲线程，而又有新任务提交，则会创建新的线程处理任务；所有的线程都会在任务执行完毕后，将返回线程池复用。
- newSingleThreadScheduledExecutor(): 该方法返回一个ScheduledExecutorService对象，线程池大小为1；ScheduledExecutorService接口扩展了ExecutorService接口的功能，它可以周期性执行某个任务。
- newScheduledThreadPool(): 该方法也返回一个ScheduledExecutorService对象，但可以指定线程数量。
1） 创建一个线程数量固定的线程池

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

public class ThreadPoolDemo {
    static class MyTask implements Runnable{
        @Override
        public void run() {
            System.out.println(System.currentTimeMillis() + ": Thread ID" + Thread.currentThread().getId());

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {

        MyTask task = new MyTask();
        ExecutorService exec = Executors.newFixedThreadPool(5); //创建线程池
        for (int i = 0; i < 10; i++) {
            exec.submit(task); //提交任务
        }

        exec.shutdown(); //关闭线程池
    }
}

2）计划任务
newScheduledThreadPool()方法返回一个ScheduledExecutorService对象，它可以根据时间需要对线程进行调度。与其它几个线程池不一样，ScheduledExecutorService并不一定会立即安排执行任务。具体如下：

public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay,
                                                  long period, TimeUnit unit);
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay,
                                                     long delay, TimeUnit unit);

对于FixedRate方式来说，任务调度的频率是一定的，在经过delay延迟后，任务开始执行，以后每间隔period时间，任务就会再次执行。对于FixedDelay方式来说，是在任务结束后，再经过delay延迟，下一次任务才开始。
FixedRate的示例：

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

public class ScheduledExecutorServiceDemo {
    public static void main(String[] args) {
        ScheduledExecutorService exec = Executors.newScheduledThreadPool(10); //创建一个可以调度的线程池
        System.out.println(System.currentTimeMillis()); //输出在所有任务开始之前的时间
        exec.scheduleAtFixedRate(new Runnable() { //
            @Override
            public void run() {
                try {
                    Thread.sleep(1000); //任务执行时间为1s
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(System.currentTimeMillis() + ": Thread ID" + Thread.currentThread().getId());
            }
        }, 1000, 2000, TimeUnit.MILLISECONDS);
    }
}

在经过1s之后第一次任务开始执行，任务执行时间是1s，任务周期是2s（也就意味着两次任务之间的间隔只有1s）。
疑问：如果任务执行时间大于任务周期，那么该任务会被堆叠么？
答：并不会，假如任务执行时间是8s，任务周期只有2s，第二次任务并不会在第一次任务执行到2s的时候开始执行，而是会在任务第一次执行完毕后（8s后）立即开始执行，即任务的周期成了8s。

3.核心线程池的内部实现

如下：

public static ExecutorService newFixedThreadPool(int nThreads) {
   return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}
public static ExecutorService newSingleThreadExecutor() {
     return new FinalizableDelegatedExecutorService
         (new ThreadPoolExecutor(1, 1,
                                 0L, TimeUnit.MILLISECONDS,
                                 new LinkedBlockingQueue<Runnable>()));
}
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

可以看到这些线程池都是对ThreadPoolExecutor类的封装；我们来看一下ThreadPoolExecutor最重要的一个构造函数：

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

corePoolSize：表示线程池中线程的数量；
maximumPoolSize:：指定了线程池中最大的线程数量；
keepAliveTime和unit：当线程池中线程的数量超过corePoolSize是，多余的线程的存活时间及其单位；
workQueue：任务队列，已提交但尚未执行的任务队列；
threadFactory：线程工厂，用于生产线程；
handler：拒绝策略，当任务太多时来不及处理，如何拒绝任务。

1）BlockingQueue
workQueue是BlockingQueue接口的一个对象，用于存放Runnable对象。有以下几种队列可以使用：
SynchronousQueue：直接提交队列，有新任务提交时，就交给线程执行；如果没有空闲线程，则创建线程；如果线程已经到达最大值，则执行拒绝策略；通常使用SynchronousQueue，都会设置很大的maximumPoolSize；
ArrayBlockingQueue：有界任务队列，若有新任务执行，并且线程池中的线程数量小于corePoolSize，则创建线程，若大于corePoolSize，则将新任务加入队列。若队列已满，并且线程池中的线程数量不大于maximumPoolSize，则创建新的线程执行任务；若大于maximumPoolSize，则执行拒绝策略。
LinkedBlockingQueue：无界任务队列，与ArrayBlockingQueue不同的是，它的队列不存在任务入队失败的情况；因此当线程数增加到corePoolSize时，就不会继续增加；
PriorityBlockingQueue：优先任务队列，它是特殊的无界队列，任务按照优先级执行；
2）RejectedExecutionHandler
拒绝策略，当任务数量超过系统实际承载的能力时，这时就需要用到拒绝策略；JDK内置的策略如下：
AbortPolicy：直接抛异常；
CallerRunsPolicy：只要线程池未关闭，该策略直接在调用者的线程中运行当前被丢弃的任务，显然这样做不会真的丢弃任务；
DiscardOldestPolicy：丢弃一个最老的请求，即将被执行的任务；
DiscardPolicy：丢弃不能处理的任务；

import java.util.concurrent.*;

public class RejectPoliceDemo {
    static class MyTask implements Runnable{
        @Override
        public void run() {
            System.out.println(System.currentTimeMillis() + ": Thread ID" + Thread.currentThread().getId());

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        MyTask myTask = new MyTask();
        ThreadPoolExecutor exec = new ThreadPoolExecutor(5, 5, 0, TimeUnit.SECONDS, new LinkedBlockingQueue<>(10), Executors.defaultThreadFactory(),
                new RejectedExecutionHandler() { //自定义拒绝策略
                    @Override
                    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                        System.out.println(r.toString() + "is discard. ");
                    }
                });

        for (int i = 0; i < 100; i++) {
            exec.submit(myTask);
        }
    }
}