Java线程池介绍及应用

“线程池”，顾名思义就是一个线程缓存，和数据库连接池类似。线程是稀缺资源，如果被无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，因此Java中提供线程池对线程进行统一分配、调优和监控。

线程池介绍

在web开发中，服务器需要接受并处理请求，所以会为一个请求来分配一个线程来进行 处理。如果每次请求都新创建一个线程的话实现起来非常简便，但是存在一个问题:

如果并发的请求数量非常多，但每个线程执行的时间很短，这样就会频繁的创建和销毁线程，如此一来会大大降低系统的效率。可能出现服务器在为每个请求创建新线程和销毁线程上花费的时间和消耗的系统资源要比处理实际的用户请求的时间和资源更多。

那么有没有一种办法使执行完一个任务，并不被销毁，而是可以继续执行其他的任务呢?
这就是线程池的目的了。线程池为线程生命周期的开销和资源不足问题提供了解决方 案。通过对多个任务重用线程，线程创建的开销被分摊到了多个任务上。
什么时候使用线程池?

• 单个任务处理时间比较短
• 需要处理的任务数量很大

线程池优势

• 重用存在的线程，减少线程创建，消亡的开销，提高系统性能
• 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
• 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

线程的实现方式

java实现线程有三种方式

1. 继承Thread类，重写run方法
2. 实现Runnable接口，重写run方法，交给thread类执行

public interface Runnable{
     public abstract void run();
}

3. 实现Callable接口，重写call( )方法。与Runnable接口类似，区别在于，该接口接收泛型，同时执行任务后带有返回内容。

public interface Callable<V> { 
         V call( ) throws Exception;
}

Executor线程池框架

Executor线程池框架的整个集成架构如下

Executor接口是线程池框架中最基础的部分，定义了一个用于执行Runnable任务的execute方法。

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);
}

ExecutorService是Executor下的一个重要子接口，其定义了线程池的具体行为

1. execute(Runnable command):履行Runnable类型的任务
2. submit(task):可用来提交Callable或Runnable任务，并返回代表此任务的Future 对象
3. shutdown():在完成已提交的任务后封闭办事，不再接管新任务
4. shutdownNow():停止所有正在履行的任务并封闭办事。
5. isTerminated():测试是否所有任务都履行完毕了
6. isShutdown():测试是否该ExecutorService已被关闭。

线程池状态转化

线程池有五大状态

1. RUNNING
   (1) 状态说明:线程池处在RUNNING状态时，能够接收新任务，以及对已添加的任务进行 处理。
   (2) 状态切换:线程池的初始化状态是RUNNING。换句话说，线程池被一旦被创建，就处 于RUNNING状态，并且线程池中的任务数为0。
2. SHUTDOWN
   (1) 状态说明:线程池处在SHUTDOWN状态时，不接收新任务，但能处理已添加的任务。
   (2) 状态切换:调用线程池的shutdown()接口时，线程池由RUNNING -> SHUTDOWN。
3. STOP
   (1) 状态说明:线程池处在STOP状态时，不接收新任务，不处理已添加的任务，并且会中 断正在处理的任务。
   (2) 状态切换:调用线程池的shutdownNow()接口时，线程池由(RUNNING or SHUTDOWN ) -> STOP。
4. TIDYING
   (1) 状态说明:当所有的任务已终止，ctl记录的”任务数量”为0，线程池会变为TIDYING 状态。当线程池变为TIDYING状态时，会执行钩子函数terminated()。terminated()在 ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时，进行相应的处理; 可以通过重载terminated()函数来实现。
   (2) 状态切换:当线程池在SHUTDOWN状态下，阻塞队列为空并且线程池中执行的任务也 为空时，就会由 SHUTDOWN -> TIDYING。 当线程池在STOP状态下，线程池中执行的 任务为空时，就会由STOP -> TIDYING。
5. TERMINATED
   (1)状态说明：线程池彻底终止，就变成TERMINATED状态。
   (2)状态切换:线程池处在TIDYING状态时，执行完terminated()之后，就会由 TIDYING - > TERMINATED。
   

JDK提供的线程池可以分为两大类，一种基于ThreadPoolExecutor实现的线程池，一类基于ScheduledThreadPoolExecutor实现的定时线程池。本文重点介绍ThreadPoolExecutor。

线程池的创建

线程池可以通过Executors工具类调用其静态方法直接创建，返回一个ExecutorService接口实例对象引用，用于管理线程池。

public class Executors {
     /**
     **创建一个可重用固定个数的线程池，以共享的无界队列方式来运行这些线程。
     *****/
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
}

    /***
    **创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定
    **顺序(FIFO, LIFO, 优先级)执行。
    *****/
    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

   /**
   *可缓存线程池，先查看池中有没有以前建立的线程，如果有，就直接使用。如果没有，
   *就建一个新的线程加入池中，缓存型池子通常用于执行一些生存期很短的异步型任务
   */
    public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>(),
                                      threadFactory);
    }
}



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

任务提交

1、public void execute() //提交任务无返回值
2、public Future<?> submit() //任务执行完成后有返回值

参数解释

corePoolSize 线程池中的核心线程数，当提交一个任务时，线程池创建一个新线程执行任务，直到当前线程数等于corePoolSize;如果当前线程数为corePoolSize，继续提交的任务被保存到 阻塞队列中，等待被执行;如果执行了线程池的prestartAllCoreThreads()方法，线程池会 提前创建并启动所有核心线程。
maximumPoolSize 线程池中允许的最大线程数。如果当前阻塞队列满了，且继续提交任务，则创建新的线程执行任务，前提是当前线程数小于maximumPoolSize。
keepAliveTime 线程池维护线程所允许的空闲时间。当线程池中的线程数量大于corePoolSize的时候，如果这时没有新的任务提交，核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过keepAliveTime;
unit keepAliveTime的单位;
workQueue 用来保存等待被执行的任务的阻塞队列，且任务必须实现Runable接口，在JDK中提供了如下阻塞队列:

1. ArrayBlockingQueue:基于数组结构的有界阻塞队列，按FIFO排序任务;
2. LinkedBlockingQuene:基于链表结构的阻塞队列，按FIFO排序任务，吞吐量通常要高于ArrayBlockingQuene;
3. SynchronousQuene:一个不存储元素的阻塞队列，每个插入操作必须等到 另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于 LinkedBlockingQuene;
4. priorityBlockingQuene:具有优先级的无界阻塞队列;

threadFactory它是ThreadFactory类型的变量，用来创建新线程。默认使用 Executors.defaultThreadFactory() 来创建线程。使用默认的ThreadFactory来创建线程 时，会使新创建的线程具有相同的NORM_PRIORITY优先级并且是非守护线程，同时也设 置了线程的名称。

handler 线程池的饱和策略，当阻塞队列满了，且没有空闲的工作线程，如果继续提交任务，必须采取一种策略处理该任务，线程池提供了4种策略:

1. AbortPolicy:直接抛出异常，默认策略;
2. CallerRunsPolicy:用调用者所在的线程来执行任务;
3. DiscardOldestPolicy:丢弃阻塞队列中靠最前的任务，并执行当前任务;
4. DiscardPolicy:直接丢弃任务;

上面的4种策略都是ThreadPoolExecutor的内部类。当然也可以根据应用场景实现RejectedExecutionHandler接口，自定义饱和策略，如 记录日志或持久化存储不能处理的任务。