Java并发编程-线程池（一）

序

Java中的线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序 都可以使用线程池。

在开发过程中，合理地使用线程池能够带来3个好处。

• 第一:降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

• 第二:提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。

• 第三:提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源， 还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。但是，要做到合理利用 线程池，必须对其实现原理有所了解。

关于线程池，印象最深的。我记得我上学的当时大二有个大作业是 自己实现一个多人联机的消消乐。消除的动画是通过线程来实现的，但是当时不知道有线程池的概念，每次都新建线程，导致消除动画非常卡顿。

线程池的使用

线程池的创建

****我们可以通过ThreadPoolExecutor来创建一个线程池。

 new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, milliseconds,runnableTaskQueue, handler);

参数： 面试常问

1. corePoolSize(线程池的基本大小):

当提交一个任务到线程池时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务，也会创建线程，等到需要执行的任务数大于线程池基本大小时就不再创建。

如果调用了线程池的prestartAllCoreThreads()方法， 线程池会提前创建并启动所有基本线程。

• runnableTaskQueue(任务队列):

用于保存等待执行的任务的阻塞队列。

可以选择以下几 个阻塞队列。 这几个队列我们前面讲过，这里只是带过。

• ArrayBlockingQueue:是一个基于数组结构的有界阻塞队列，此队列按FIFO(先进先出)原 则对元素进行排序。

• LinkedBlockingQueue:一个基于链表结构的阻塞队列，此队列按FIFO排序元素，吞吐量通 常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用了这个队列。

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

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

• maximumPoolSize:

线程池允许创建的最大线程数。如果队列满了，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。值得注意的是，如果使用了无界的任务队列这个参数就没什么效果。

• ThreadFactory：从字面意思，用于设置创建线程的工厂，可以通过线程工厂给每个创建出来的线程设置更有意义的名字。我们也使用google 开源的guava提供的ThreadFactoryBuilder可以快速给线程池里的线程设置有意义的名字，代码如下。

new ThreadFactoryBuilder().setNameFormat("XX-task-%d").build(); 

下面会给出完整的代码。

• RejectedExecutionHandler(饱和策略):

当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务。这个策略默认情况下是AbortPolicy，表示无法 处理新任务时抛出异常。简单过一下4种策略：

• AbortPolicy:直接抛出异常。

• CallerRunsPolicy:只用调用者所在线程来运行任务。

• DiscardOldestPolicy:丢弃队列里最近的一个任务，并执行当前任务。

• DiscardPolicy:不处理，丢弃掉。

当然，也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略。如记录 日志或持久化存储不能处理的任务。

• keepAliveTime

线程池的工作线程空闲后，保持存活的时间。所以， 如果任务很多，并且每个任务执行的时间比较短，可以调大时间，提高线程的利用率。

• TimeUnit：线程活动保持时间的单位

可选的单位有天(DAYS)、小时(HOURS)、分钟 (MINUTES)、毫秒(MILLISECONDS)、微秒(MICROSECONDS，千分之一毫秒)和纳秒 (NANOSECONDS，千分之一微秒)。

提交任务

可以使用两个方法向线程池提交任务，分别为execute()和submit()方法。

execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功。

从代码里也可以知道 execute()方法输入的任务是一个Runnable类的实例。

public interface Executor {
    /**
     * Executes the given command at some time in the future.  The command
     * may execute in a new thread, in a pooled thread, or in the calling
     * thread, at the discretion of the {@code Executor} implementation.
     *
     * @param command the runnable task
     * @throws RejectedExecutionException if this task cannot be
     * accepted for execution
     * @throws NullPointerException if command is null
     */
    void execute(Runnable command);
} 

submit()方法用于提交需要返回值的任务。

看下代码ThreadPoolDemo.java， submit部分：

package com.zhaowa.galaxy.example.threadpool;

import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.util.concurrent.*;

public class ThreadPoolDemo {
    private static ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
            .setNameFormat("demo-pool-%d").build();
    private static ExecutorService pool = new ThreadPoolExecutor(
            2,
            20,
            0L,
            TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<Runnable>(2),
            namedThreadFactory,
            new ThreadPoolExecutor.AbortPolicy());
    private static class ResultThread implements Callable<String> {
        @Override
        public String call() throws Exception {
            System.out.println(Thread.currentThread().getState()+"----------"
                    +Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return Thread.currentThread().getName();
        }
    }
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            Future<String> future = pool.submit(new ResultThread());
            try {
                System.out.println("main thread get result: " + future.get());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

线程池会返回一个future类型的对象，通过这个 future对象可以判断任务是否执行成功，

并且可以通过future的get()方法来获取返回值，get()方 法会阻塞当前线程直到任务完成，而使用get(long timeout，TimeUnit unit)方法则会阻塞当前线 程一段时间后立即返回，这时候有可能任务没有执行完。

关闭线程池

可以通过调用线程池的shutdown或shutdownNow方法来关闭线程池。

它们的原理是：遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程，所以无法响应中断的任务 可能永远无法终止。

但是它们存在一定的区别，shutdownNow首先将线程池的状态设置成 STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表，而 shutdown只是将线程池的状态设置成SHUTDOWN状态，然后中断所有没有正在执行任务的线程。 只要调用了这两个关闭方法中的任意一个，isShutdown方法就会返回true。

当所有的任务都已关闭后，才表示线程池关闭成功，这时调用isTerminaed方法会返回true。

至于应该调用哪一种方法来关闭线程池，应该由提交到线程池的任务特性决定，通常调用shutdown方法来关闭线程池，如果任务不一定要执行完，则可以调用shutdownNow方法。

看下代码，为了方便看到效果，我们把submit换成 pool.execute(new NoResultThread(i))

public static void main(String[] args) {
    for (int i = 0; i < 10; i++) {
        pool.execute(new NoResultThread(i));
    }
     //shutdown 验证
    System.out.println("执行shutdown！ "); 
    // 会继续执行并且完成所有未执行的任务, 新提交的任务会被reject（通过reject策略）
    pool.shutdown();  
    for (int i = 10; i < 12; i++) {
        try {
            pool.execute(new NoResultThread(i));
        }catch (Exception e) {
            e.printStackTrace(); // 防止 shutdown 之后提交任务异常导致主线程终止
        }
    }
    /** shutdownnow 验证
    System.out.println("执行shutdownnow! ");
    // 会清除所有未执行的任务并且在运行线程上调用interrupt()
     List<Runnable> runnableList = pool.shutdownNow(); 
     **/
    System.out.println("pool shutdown state: " + pool.isShutdown());
    while (true) {
        if (pool.isTerminated()) {
            System.out.println("pool terminated!");
            break;
        }else {
            System.out.println("pool terminated state: " + pool.isTerminated());
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}