Java线程池实现原理与技术II

为了能够更好地控制多线程，JDK提供了一套Executor框架，帮助开发人员有效地进行线程控制。Executor框架无论是newFixedThreadPool()方法、newSingleThreadExecutor()方法还是ewCachedThreadPool()方法，其内部实现均使用了 ThreadPoolExecutor：

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }
    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>()));
    }

由以上线程池的实现代码可以知道，它们只是对 ThreadPoolExecutor 类的封装。为何 ThreadPoolExecutor 类有如此强大的功能？来看一下 ThreadPoolExecutor 最重要的构造方法。

1、构造方法

ThreadPoolExecutor最重要的构造方法如下：

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

方法参数如下：

ThreadPoolExecutor的使用示例，通过execute()方法提交任务。

public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(4, 5, 0, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
        for (int i = 0; i < 10; i++) {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
        executor.shutdown();
    }

或者通过submit()方法提交任务

public static void main(String[] args) throws ExecutionException, InterruptedException {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(4, 5, 0, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
        List<Future> futureList = new Vector<>();
        //在其它线程中执行100次下列方法
        for (int i = 0; i < 100; i++) {
            futureList.add(executor.submit(new Callable<String>() {
                @Override
                public String call() throws Exception {
                    return Thread.currentThread().getName();
                }
            }));
        }
        for (int i = 0;i<futureList.size();i++){
            Object o = futureList.get(i).get();
            System.out.println(o.toString());
        }
        executor.shutdown();
    }

运行结果：

...
pool-1-thread-4
pool-1-thread-3
pool-1-thread-2

下面主要讲解ThreadPoolExecutor的构造方法中workQueue和RejectedExecutionHandler参数，其它参数都很简单。

2、workQueue任务队列

用于保存等待执行的任务的阻塞队列。可以选择以下几个阻塞队列。

• ArrayBlockingQueue: 是一个基于数组结构的有界阻塞队列，按FIFO原则进行排序

• LinkedBlockingQueue: 一个基于链表结构的阻塞队列，吞吐量高于ArrayBlockingQueue。静态工厂方法Excutors.newFixedThreadPool()使用了这个队列

• SynchronousQueue: 一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量高于LinkedBlockingQueue，静态工厂方法Excutors.newCachedThreadPool()使用了这个队列

• PriorityBlockingQueue: 一个具有优先级的无限阻塞队列。

3、RejectedExecutionHandler饱和策略

当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略还处理新提交的任务。它可以有如下四个选项：

• AbortPolicy : 直接抛出异常，默认情况下采用这种策略
  
• CallerRunsPolicy : 只用调用者所在线程来运行任务
  
• DiscardOldestPolicy : 丢弃队列里最近的一个任务，并执行当前任务
  
• DiscardPolicy : 不处理，丢弃掉
  

更多的时候，我们应该通过实现RejectedExecutionHandler 接口来自定义策略，比如记录日志或持久化存储等。

4、submit()与execute()

可以使用execute和submit两个方法向线程池提交任务。

1. execute方法用于提交不需要返回值的任务，利用这种方式提交的任务无法得知是否正常执行

2. submit方法用于提交一个任务并带有返回值，这个方法将返回一个Future类型对象。可以通过这个返回对象判断任务是否执行成功，并且可以通过future.get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成。

5、shutdown()与shutdownNow()

可以通过调用 shutdown() 或 shutdownNow() 方法来关闭线程池。它们的原理是遍历线程池中的工作线程，然后逐个调用线程的 interrupt 方法来中断线程，所以无法响应中断的任务可能永远无法停止。

这俩方法的区别是，shutdownNow() 首先将线程池的状态设置成STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表，而 shutdown() 只是将线程池的状态设置成 SHUTDOWN 状态，然后中断所有没有正在执行任务的线程。

只要调用了这两个关闭方法的任意一个，isShutdown 方法就会返回 true。当所有的任务都已关闭了，才表示线程池关闭成功，这时调用 isTerminaced 方法会返回 true。

通常调用 shutdown() 方法来关闭线程池，如果任务不一定要执行完，则可以调用 shutdownNow() 方法。

6、合理配置线程池

要想合理地配置线程池，首先要分析任务特性

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

性质不同的任务可以用不同规模的线程池分开处理。

CPU密集型任务应该配置尽可能少的线程，如配置N+1个线程，N位CPU的个数。

而IO密集型任务线程并不是一直在执行任务，则应配置尽可能多的线程，如2*N。

混合型任务，如果可以拆分，将其拆分成一个CPU密集型任务和一个IO密集型任务，只要这两个任务执行的时间相差不是太大，那么分解后执行的吞吐量将高于串行执行的吞吐量。如果这两个任务执行的时间相差很大，则没有必要进行分解。可以通过

Runtime.getRuntime().availableProcessors()方法获得当前设备的CPU个数。

优先级不同的任务可以使用优先级队列PriorityBlockingQueue来处理。它可以让优先级高的任务先执行。

7、线程池的监控

由于大量的使用线程池，所以很有必要对其进行监控。可以通过继承线程池来自定义线程池，重写线程池的beforeExecute、afterExecute 和 terminated 方法，也可以在任务执行前，执行后和线程池关闭前执行一些代码来进行监控。在监控线程池的时候可以使用一下属性：

(1) taskCount：线程池需要执行的任务数量

(2) completedTaskCount：线程池在运行过程中已完成的任务数量，小于或等于taskCount

(3) largestPoolSize： 线程池里曾经创建过最大的线程数量。通过这个数据可以知道线程池是否曾经满过。如该数值等于线程池最大大小，则表示线程池曾经满过。

(4) getPoolSize：线程池的线程数量。如果线程池不销毁的话，线程池里的线程不会自动销毁，所以这个大小只增不减。

(5) getActiveCount：获取活动的线程数