Java多线程—Java线程池Executor

Java多线程—Java线程池Executor

一、Executor框架简介：

在HotSpot VM的线程模型中，Java线程（java.lang.Thread）被一对一映射为本地操作系统线程。Java线程启动时会创建一个本地操作系统线程；当该Java线程终止时，这个操作系统线程也会被回收。操作系统会调度所有线程并将它们分配给可用的CPU。
在上层，Java多线程程序通常把应用分解为若干个任务，然后使用用户级的调度器（Executor框架）将这些任务映射为固定数量的线程；在底层，操作系统内核将这些线程映射到硬件处理器上。这种两级调度模型的示意图如图：

从图中可以看出，应用程序通过Executor框架控制上层的调度；而下层的调度由操作系统内核控制，下层的调度不受应用程序的控制。

Executor框架的结构与成员

Executor框架主要由3大部分组成如下：

• 任务。包括被执行任务需要实现的接口：Runnable接口或Callable接口。
• 任务的执行。包括任务执行机制的核心接口Executor，以及继承自Executor的ExecutorService接口。Executor框架有两个关键类实现了ExecutorService接口（ThreadPoolExecutor和ScheduledThreadPoolExecutor）。
• 异步计算的结果。包括接口Future和实现Future接口的FutureTask类。

类和接口的简介：

Executor框架包含的主要的类与接口如图：

• Executor是一个接口，它是Executor框架的基础，它将任务的提交与任务的执行分离开来。
• ThreadPoolExecutor是线程池的核心实现类，用来执行被提交的任务。
• ScheduledThreadPoolExecutor是一个实现类，可以在给定的延迟后运行命令，或者定期执行命令。ScheduledThreadPoolExecutor比Timer更灵活，功能更强大。
• Future接口和实现Future接口的FutureTask类，代表异步计算的结果。
• Runnable接口和Callable接口的实现类，都可以被ThreadPoolExecutor或Scheduled-ThreadPoolExecutor执行。

Executor框架的使用示意图如图：

主线程首先要创建实现Runnable或者Callable接口的任务对象。工具类Executors可以把一个Runnable对象封装为一个Callable对象（Executors.callable（Runnable task）或Executors.callable（Runnable task，Object resule））。
然后可以把Runnable对象直接交给ExecutorService执行（ExecutorService.execute（Runnablecommand））；或者也可以把Runnable对象或Callable对象提交给ExecutorService执行（Executor-Service.submit（Runnable task）或ExecutorService.submit（Callabletask））。
如果执行ExecutorService.submit（…），ExecutorService将返回一个实现Future接口的对象（到目前为止的JDK中，返回的是FutureTask对象）。由于FutureTask实现了Runnable，程序员也可以创建FutureTask，然后直接交给ExecutorService执行。
最后，主线程可以执行FutureTask.get()方法来等待任务执行完成。主线程也可以执行FutureTask.cancel（boolean mayInterruptIfRunning）来取消此任务的执行。

Executor框架的成员：

主要成员：ThreadPoolExecutor、ScheduledThreadPoolExecutor、Future接口、Runnable接口、Callable接口和Executors。

 ThreadPoolExecutor：

ThreadPoolExecutor通常使用工厂类Executors来创建。Executors可以创建3种类型的ThreadPoolExecutor：SingleThreadExecutor、FixedThreadPool和CachedThreadPool。

• FixedThreadPool适用于为了满足资源管理的需求，而需要限制当前线程数量的应用场景，它适用于负载比较重的服务器。
• SingleThreadExecutor适用于需要保证顺序地执行各个任务；并且在任意时间点，不会有多个线程是活动的应用场景。
• CachedThreadPool是大小无界的线程池，适用于执行很多的短期异步任务的小程序，或者是负载较轻的服务器。

ScheduledThreadPoolExecutor：

ScheduledThreadPoolExecutor通常使用工厂类Executors来创建。Executors可以创建2种类型的ScheduledThreadPoolExecutor，如下：

• ScheduledThreadPoolExecutor。包含若干个线程的ScheduledThreadPoolExecutor。适用于需要多个后台线程执行周期任务，同时为了满足资源管理的需求而需要限制后台线程的数量的应用场景
• SingleThreadScheduledExecutor。只包含一个线程的ScheduledThreadPoolExecutor。适用于需要单个后台线程执行周期任务，同时需要保证顺序地执行各个任务的应用场景。

Future接口：

Future接口和实现Future接口的FutureTask类用来表示异步计算的结果。当我们把Runnable接口或Callable接口的实现类提交（submit）给ThreadPoolExecutor或ScheduledThreadPoolExecutor时，ThreadPoolExecutor或ScheduledThreadPoolExecutor会向我们返回一个FutureTask对象。

Runnable接口和Callable接口：

Runnable接口和Callable接口的实现类，都可以被ThreadPoolExecutor或Scheduled-ThreadPoolExecutor执行。它们之间的区别是Runnable不会返回结果，而Callable可以返回结果。
除了可以自己创建实现Callable接口的对象外，还可以使用工厂类Executors来把一个Runnable包装成一个Callable。

二、ThreadPoolExecutor详解：

Executor框架最核心的类是ThreadPoolExecutor，它是线程池的实现类，主要由下列4个组件构成。

• corePool：核心线程池的大小。
• maximumPool：最大线程池的大小。
• BlockingQueue：用来暂时保存任务的工作队列。
• RejectedExecutionHandler：当ThreadPoolExecutor已经关闭或ThreadPoolExecutor已经饱和时（达到了最大线程池大小且工作队列已满），execute()方法将要调用的Handler。

通过Executor框架的工具类Executors，可以创建3种类型的ThreadPoolExecutor。

• FixedThreadPool。
• SingleThreadExecutor。
• CachedThreadPool。

FixedThreadPool详解

FixedThreadPool被称为可重用固定线程数的线程池。

FixedThreadPool的corePoolSize和maximumPoolSize都被设置为创建FixedThreadPool时指定的参数nThreads。

当线程池中的线程数大于corePoolSize时，keepAliveTime为多余的空闲线程等待新任务的最长时间，超过这个时间后多余的线程将被终止。这里把keepAliveTime设置为0L，意味着多余的空闲线程会被立即终止。

FixedThreadPool的execute()方法的运行示意图如图：

1）如果当前运行的线程数少于corePoolSize，则创建新线程来执行任务。
2）在线程池完成预热之后（当前运行的线程数等于corePoolSize），将任务加入LinkedBlockingQueue。
3）线程执行完1中的任务后，会在循环中反复从LinkedBlockingQueue获取任务来执行。 

FixedThreadPool使用无界队列LinkedBlockingQueue作为线程池的工作队列（队列的容量为Integer.MAX_VALUE）。使用无界队列作为工作队列会对线程池带来如下影响。

1）当线程池中的线程数达到corePoolSize后，新任务将在无界队列中等待，因此线程池中的线程数不会超过corePoolSize。
2）由于1，使用无界队列时maximumPoolSize将是一个无效参数。
3）由于1和2，使用无界队列时keepAliveTime将是一个无效参数。
4）由于使用无界队列，运行中的FixedThreadPool（未执行方法shutdown()或shutdownNow()）不会拒绝任务（不会调用RejectedExecutionHandler.rejectedExecution方法）。

代码示例：

public class ThreadForpools implements Runnable {
    private Integer index;

    public ThreadForpools(Integer index) {
        this.index = index;
    }

    @Override
    public void run() {
        /***
         * 业务......省略
         */
        try {
            System.out.println("开始处理线程！！！");
            Thread.sleep(index * 100);
            System.out.println("我的线程标识是：" + index +  "  " + this.toString());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Threadpools2 {
    /**
     * 我们获取四次次线程，观察4个线程地址
     *
     * @param args
     */
    public static void main(String[] args) {
        /**
         * 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
         * 每次只有两个线程在处理，当第一个线程执行完毕后，新的线程进来开始处理（线程地址不一样）
         */
        //线程池允许同时存在两个线程
        ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(2);
        System.out.println("****************************newFixedThreadPool*******************************");
        for (int i = 0; i < 20; i++) {
            final int index = i;
            newFixedThreadPool.execute(new ThreadForpools(index));
        }
    }
}

运行结果：

****************************newFixedThreadPool*******************************
开始处理线程！！！
开始处理线程！！！
我的线程标识是：0  com.emrubik.thread.s10.ThreadForpools@4cf319d1
开始处理线程！！！
我的线程标识是：1  com.emrubik.thread.s10.ThreadForpools@1bcc4803
开始处理线程！！！
我的线程标识是：2  com.emrubik.thread.s10.ThreadForpools@4234fe3f
我的线程标识是：3  com.emrubik.thread.s10.ThreadForpools@150ba50a

SingleThreadExecutor详解

SingleThreadExecutor是使用单个worker线程的Executor。

SingleThreadExecutor的corePoolSize和maximumPoolSize被设置为1。其他参数与FixedThreadPool相同。SingleThreadExecutor使用无界队列LinkedBlockingQueue作为线程池的工作队列（队列的容量为Integer.MAX_VALUE）。SingleThreadExecutor使用无界队列作为工作队列对线程池带来的影响与FixedThreadPool相同。

SingleThreadExecutor的运行示意图如图：

说明：

1）如果当前运行的线程数少于corePoolSize（即线程池中无运行的线程），则创建一个新线程来执行任务。
2）在线程池完成预热之后（当前线程池中有一个运行的线程），将任务加入Linked-BlockingQueue。
3）线程执行完1中的任务后，会在一个无限循环中反复从LinkedBlockingQueue获取任务来执行。

代码示例：

public class Threadpools4 {
    /**
     * 我们获取四次次线程，观察4个线程地址
     *
     * @param args
     */
    public static void main(String[] args) {
        /**
         * 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
         * 只存在一个线程，顺序执行
         */
        ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
        System.out.println("****************************newFixedThreadPool*******************************");
        for (int i = 0; i < 4; i++) {
            final int index = i;
            newSingleThreadExecutor.execute(new ThreadForpools(index));
        }
    }
}

运行结果：

****************************newFixedThreadPool*******************************
开始处理线程！！！
我的线程标识是：0  com.emrubik.thread.s10.ThreadForpools@b148489
开始处理线程！！！
我的线程标识是：1  com.emrubik.thread.s10.ThreadForpools@5d36b9b
开始处理线程！！！
我的线程标识是：2  com.emrubik.thread.s10.ThreadForpools@1eceff9
开始处理线程！！！
我的线程标识是：3  com.emrubik.thread.s10.ThreadForpools@44ee61a0

CachedThreadPool详解

CachedThreadPool是一个会根据需要创建新线程的线程池。

CachedThreadPool的corePoolSize被设置为0，即corePool为空；maximumPoolSize被设置为Integer.MAX_VALUE，即maximumPool是无界的。这里把keepAliveTime设置为60L，意味着CachedThreadPool中的空闲线程等待新任务的最长时间为60秒，空闲线程超过60秒后将会被终止。
FixedThreadPool和SingleThreadExecutor使用无界队列LinkedBlockingQueue作为线程池的工作队列。CachedThreadPool使用没有容量的SynchronousQueue作为线程池的工作队列，但CachedThreadPool的maximumPool是无界的。这意味着，如果主线程提交任务的速度高于maximumPool中线程处理任务的速度时，CachedThreadPool会不断创建新线程。极端情况下，CachedThreadPool会因为创建过多线程而耗尽CPU和内存资源。

CachedThreadPool的execute()方法的执行示意图如图：

 说明如下。
1）首先执行SynchronousQueue.offer（Runnable task）。如果当前maximumPool中有空闲线程正在执行SynchronousQueue.poll（keepAliveTime，TimeUnit.NANOSECONDS），那么主线程执行offer操作与空闲线程执行的poll操作配对成功，主线程把任务交给空闲线程执行，execute()方法执行完成；否则执行下面的步骤 2）。
2）当初始maximumPool为空，或者maximumPool中当前没有空闲线程时，将没有线程执行SynchronousQueue.poll（keepAliveTime，TimeUnit.NANOSECONDS）。这种情况下，步骤1）将失败。此时CachedThreadPool会创建一个新线程执行任务，execute()方法执行完成。
3）在步骤2）中新创建的线程将任务执行完后，会执行SynchronousQueue.poll（keepAliveTime，TimeUnit.NANOSECONDS）。这个poll操作会让空闲线程最多在SynchronousQueue中等待60秒钟。如果60秒钟内主线程提交了一个新任务（主线程执行步骤1）），那么这个空闲线程将执行主线程提交的新任务；否则，这个空闲线程将终止。由于空闲60秒的空闲线程会被终止，因此长时间保持空闲的CachedThreadPool不会使用任何资源。

前面提到过，SynchronousQueue是一个没有容量的阻塞队列。每个插入操作必须等待另一个线程的对应移除操作，反之亦然。CachedThreadPool使用SynchronousQueue，把主线程提交的任务传递给空闲线程执行。CachedThreadPool中任务传递的示意图如图：

代码示例：

public class Threadpools1{
    /**
     * 我们获取四次次线程，观察4个线程地址
     *
     * @param args
     */
    public static void main(String[] args) {
        /**
         * 创建一个可缓存线程池，应用中存在的线程数可以无限大
         */
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        System.out.println("****************************newCachedThreadPool*******************************");
        for (int i = 0; i < 50; i++) {
            final int index = i;
            newCachedThreadPool.execute(new ThreadForpools(index));
        }
    }
}

运行结果：

****************************newCachedThreadPool*******************************
开始处理线程！！！
开始处理线程！！！
开始处理线程！！！
开始处理线程！！！
我的线程标识是：0  com.emrubik.thread.s10.ThreadForpools@68422010
我的线程标识是：1  com.emrubik.thread.s10.ThreadForpools@5644a213
我的线程标识是：2  com.emrubik.thread.s10.ThreadForpools@3b3595c8
我的线程标识是：3  com.emrubik.thread.s10.ThreadForpools@f710c85

ScheduledThreadPoolExecutor详解

ScheduledThreadPoolExecutor继承自ThreadPoolExecutor。它主要用来在给定的延迟之后运行任务，或者定期执行任务。ScheduledThreadPoolExecutor的功能与Timer类似，但ScheduledThreadPoolExecutor功能更强大、更灵活。Timer对应的是单个后台线程，而ScheduledThreadPoolExecutor可以在构造函数中指定多个对应的后台线程数。

ScheduledThreadPoolExecutor的执行示意图：

 DelayQueue是一个无界队列，所以ThreadPoolExecutor的maximumPoolSize在Scheduled-ThreadPoolExecutor中没有什么意义（设置maximumPoolSize的大小没有什么效果）。

ScheduledThreadPoolExecutor的执行主要分为两大部分。
1）当调用ScheduledThreadPoolExecutor的scheduleAtFixedRate()方法或者scheduleWith-FixedDelay()方法时，会向ScheduledThreadPoolExecutor的DelayQueue添加一个实现了RunnableScheduledFutur接口的ScheduledFutureTask。
2）线程池中的线程从DelayQueue中获取ScheduledFutureTask，然后执行任务。

DelayQueue封装了一个PriorityQueue，这个PriorityQueue会对队列中的Scheduled-FutureTask进行排序。排序时，time小的排在前面（时间早的任务将被先执行）。如果两个ScheduledFutureTask的time相同，就比较sequenceNumber，sequenceNumber小的排在前面（也就是说，如果两个任务的执行时间相同，那么先提交的任务将被先执行）。

ScheduledThreadPoolExecutor中的线程执行周期任务的过程：

1）线程1从DelayQueue中获取已到期的ScheduledFutureTask（DelayQueue.take()）。到期任务是指ScheduledFutureTask的time大于等于当前时间。
2）线程1执行这个ScheduledFutureTask。
3）线程1修改ScheduledFutureTask的time变量为下次将要被执行的时间。
4）线程1把这个修改time之后的ScheduledFutureTask放回DelayQueue中（Delay-Queue.add()）。

代码示例：

public class Threadpools3 {
    /**
     * 我们获取四次次线程，观察4个线程地址
     *
     * @param args
     */
    public static void main(String[] args) {
        /**
         * 创建一个定长线程池，支持定时及周期性任务执行。
         * 延迟三秒之后执行，除了延迟执行之外和newFixedThreadPool基本相同，可以用来执行定时任务
         */
        ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(2);
        System.out.println("****************************newFixedThreadPool*******************************");
        for (int i = 0; i < 4; i++) {
            final int index = i;
            //延迟三秒执行
            newScheduledThreadPool.schedule(new ThreadForpools(index), 3, TimeUnit.SECONDS);
        }
    }
}

运行结果：

****************************newFixedThreadPool*******************************
开始处理线程！！！
开始处理线程！！！
我的线程标识是：0  com.emrubik.thread.s10.ThreadForpools@36019d80
开始处理线程！！！
我的线程标识是：1  com.emrubik.thread.s10.ThreadForpools@2b4fcba0
开始处理线程！！！
我的线程标识是：2  com.emrubik.thread.s10.ThreadForpools@73030524
我的线程标识是：3  com.emrubik.thread.s10.ThreadForpools@6e4d40ad

FutureTask的实现

FutureTask的实现基于AbstractQueuedSynchronizer（以下简称为AQS）。java.util.concurrent中的很多可阻塞类（比如ReentrantLock）都是基于AQS来实现的。AQS是一个同步框架，它提供通用机制来原子性管理同步状态、阻塞和唤醒线程，以及维护被阻塞线程的队列。

每一个基于AQS实现的同步器都会包含两种类型的操作，如下。

• 至少一个acquire操作。这个操作阻塞调用线程，除非/直到AQS的状态允许这个线程继续执行。FutureTask的acquire操作为get()/get（long timeout，TimeUnit unit）方法调用。
• 至少一个release操作。这个操作改变AQS的状态，改变后的状态可允许一个或多个阻塞线程被解除阻塞。FutureTask的release操作包括run()方法和cancel（…）方法。

AQS被作为“模板方法模式”的基础类提供给FutureTask的内部子类Sync，这个内部子类只需要实现状态检查和状态更新的方法即可，这些方法将控制FutureTask的获取和释放操作。具体来说，Sync实现了AQS的tryAcquireShared（int）方法和tryReleaseShared（int）方法，Sync通过这两个方法来检查和更新同步状态。

FutureTask的设计示意图如图：

 FutureTask.get()方法会调用AQS.acquireSharedInterruptibly（int arg）方法，这个方法的执行过程如下。
1）调用AQS.acquireSharedInterruptibly（int arg）方法，这个方法首先会回调在子类Sync中实现的tryAcquireShared()方法来判断acquire操作是否可以成功。acquire操作可以成功的条件为：state为执行完成状态RAN或已取消状态CANCELLED，且runner不为null。
2）如果成功则get()方法立即返回。如果失败则到线程等待队列中去等待其他线程执行release操作。
3）当其他线程执行release操作（比如FutureTask.run()或FutureTask.cancel（…））唤醒当前线程后，当前线程再次执行tryAcquireShared()将返回正值1，当前线程将离开线程等待队列并唤醒它的后继线程（这里会产生级联唤醒的效果，后面会介绍）。
4）最后返回计算的结果或抛出异常。

FutureTask.run()的执行过程如下。
1）执行在构造函数中指定的任务（Callable.call()）。
2）以原子方式来更新同步状态（调用AQS.compareAndSetState（int expect，int update），设置state为执行完成状态RAN）。如果这个原子操作成功，就设置代表计算结果的变量result的值为Callable.call()的返回值，然后调用AQS.releaseShared（int arg）。
3）AQS.releaseShared（int arg）首先会回调在子类Sync中实现的tryReleaseShared（arg）来执行release操作（设置运行任务的线程runner为null，然会返回true）；AQS.releaseShared（int arg），然后唤醒线程等待队列中的第一个线程。
4）调用FutureTask.done()。

线程监控示例：

public class NewThreadPoolExecutor extends ThreadPoolExecutor {
    private long tempCompletedTaskCount;

    private long tempTaskCount;

    public NewThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
                                 BlockingQueue workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

    public NewThreadPoolExecutor(int nThreads) {
        super(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue());
    }

    public long getCompletedTaskCount() {
        return super.getCompletedTaskCount() - tempCompletedTaskCount;
    }

    public long getTaskCount() {
        return super.getTaskCount() - tempTaskCount;
    }

    public void resetTaskCount() {
        if (super.getCompletedTaskCount() == super.getTaskCount()) {
            tempCompletedTaskCount = super.getCompletedTaskCount();
            tempTaskCount = super.getTaskCount();
        }
    }

}

public class TestThreadCount {
    private static NewThreadPoolExecutor executorService = new NewThreadPoolExecutor(5);

    public static void main(String[] args) throws Exception {
        final Future f1 = executorService.submit(new Callable() {
            @Override
            public Integer call() throws Exception {
                TimeUnit.SECONDS.sleep(2);
                int temp = 0;
                while (temp++ < 30)
                    System.out.println("F1-" + temp + Thread.currentThread().getName());
                return Integer.valueOf(temp);
            }
        });
        final Future f2 = executorService.submit(new Callable() {
            @Override
            public Integer call() throws Exception {
                int temp = 0;
                while (temp++ < 30)
                    System.out.println("F2-" + temp + Thread.currentThread().getName());
                ;
                return Integer.valueOf(temp);
            }
        });
        final Future f3 = executorService.submit(new Callable() {
            @Override
            public Integer call() throws Exception {
                int temp = 0;
                while (temp++ < 30)
                    System.out.println("F3-" + temp + Thread.currentThread().getName());
                ;
                return Integer.valueOf(temp);
            }
        });
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println(Thread.currentThread().getName());
                    System.out.println(f1.get() + f2.get() + f3.get());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
            }
        });

        System.out.println("【线程活跃数】" + executorService.getActiveCount());
        System.out.println("【总任务数】" + executorService.getTaskCount());
        System.out.println("【已完成任务数】" + executorService.getCompletedTaskCount());
        TimeUnit.SECONDS.sleep(8);
        System.out.println("【线程活跃数】" + executorService.getActiveCount());
        System.out.println("【总任务数】" + executorService.getTaskCount());
        System.out.println("【已完成任务数】" + executorService.getCompletedTaskCount());

        // 重新计数
        executorService.resetTaskCount();
        final Future f4 = executorService.submit(new Callable() {
            @Override
            public Integer call() throws Exception {
                TimeUnit.SECONDS.sleep(3);
                int temp = 0;
                while (temp++ < 30)
                    System.out.println("F4-" + temp + Thread.currentThread().getName());
                ;
                return Integer.valueOf(temp);
            }
        });
        f4.get();
        System.out.println("【线程活跃数】" + executorService.getActiveCount());
        System.out.println("【总任务数】" + executorService.getTaskCount());
        System.out.println("【已完成任务数】" + executorService.getCompletedTaskCount());
    }

}