java 线程池全面解析

java  线程池全面解析

一、什么是线程池？

很简单，简单看名字就知道是装有线程的池子，我们可以把要执行的多线程交给线程池来处理，和连接池的概念一样，通过维护一定数量的线程池来达到多个线程的复用。

二、线程池的好处？

我们知道不用线程池的话，每个线程都要通过new Thread().start()的方式来创建并运行一个线程，线程少的话这不会是问题，而真实环境可能会开启多个线程让系统和程序达到最佳效率，当线程数达到一定数量就会耗尽系统的CPU和内存资源，也会造成GC频繁收集和停顿，因为每次创建和销毁一个线程都是要消耗系统资源的，如果为每个任务都创建线程这无疑是一个很大的性能瓶颈。所以，线程池中的线程复用极大节省了系统资源，当线程一段时间不再有任务处理时它也会自动销毁，而不会长驻内存。

三、线程池核心类

在java.util.concurrent包中我们能找到线程池的定义，其中ThreadPoolExecutor是我们线程池核心类，首先看看线程池类的主要参数有哪些。

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

(1)corePoolSize：核心线程数=线程池的核心大小=最小的线程池大小

(2)maximumPoolSize：最大线程数=最大线程池大小

(3)keepAliveTime ：空余线程存活时间，指的是超过corePoolSize的空余线程达到多长时间销毁（详见文末解析）

(4)unit：销毁时间单位。

(5)workQueue：存储等待执行线程的工作队列

(6)threadFactory：创建线程的工厂，一般用默认即可。

(7)handler：拒绝策略，当工作队列、线程池全已满时如何拒绝新任务，默认抛出异常。

四、线程池的工作流程

1、如果线务程池中的线程小于corePoolSize时就会创建新线程直接执行任。

2、如果线程池中的线程大于corePoolSize时就会暂时把任务存储到工作队列workQueue中等待执行。

3、如果工作队列workQueue也满时：当线程数小于最大线程池数maximumPoolSize时就会创建新线程来处理，而线程数大于等于最大线程池数maximumPoolSize时就会执行拒绝策略。

五、线程池分类

Executors是jdk里面提供的创建线程池的工厂类，它默认提供了4种常用的线程池应用，而不必我们去重复构造。

弊端：

线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让使用者更加明确线程池的运行规则，规避资源耗尽的风险。

1、newFixedThreadPool

固定线程池，核心线程数和最大线程数固定相等，而空闲存活时间为0毫秒，说明此参数也无意义，工作队列为最大为Integer.MAX_VALUE大小的阻塞队列。当执行任务时，如果线程都很忙，就会丢到工作队列等有空闲线程时再执行，队列满就执行默认的拒绝策略。

主要问题是堆积的请求处理队列可能会耗费非常大的内存，甚至产生OOM。

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

2、newCachedThreadPool

带缓冲线程池，从构造看核心线程数为0，最大线程数为Integer最大值大小，超过0个的空闲线程在60秒后销毁，SynchronousQueue这是一个直接提交的队列，意味着每个新任务都会有线程来执行，如果线程池有可用线程则执行任务，没有的话就创建一个来执行，线程池中的线程数不确定，一般建议执行速度较快较小的线程，不然这个最大线程池边界过大容易造成内存溢出。

主要问题是线程数最多数是Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至OOM。

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

3、newSingleThreadExecutor

 单线程线程池，核心线程数和最大线程数均为1，空闲线程存活0毫秒同样无意思，意味着每次只执行一个线程，多余的先存储到工作队列，一个一个执行，保证了线程的顺序执行。

主要问题是堆积的请求处理队列可能会耗费非常大的内存，甚至产生OOM。

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

4、newScheduledThreadPool

调度线程池，即按一定的周期执行任务，即定时任务，对ThreadPoolExecutor进行了包装而已。

主要问题是线程数最多数是Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至OOM。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

六、拒绝策略

1、AbortPolicy：简单粗暴，直接抛出拒绝异常，这也是默认的拒绝策略。

2、CallerRunsPolicy：如果线程池未关闭，则会在调用者线程中直接执行新任务，这会导致主线程提交线程性能变慢。

3、DiscardPolicy：    从方法看没做任务操作，即表示不处理新任务，即丢弃。

4、DiscardOldestPolicy：抛弃最老的任务，就是从队列取出最老的任务然后放入新的任务进行执行。

七、如何提交线程

提交一个线程区别如下：

1）es.submit(xxRunnble);

返回一个Future对象，如果想知道线程结果就使用submit提交，而且它能在主线程中通过Future的get方法捕获线程中的异常。

2）es.execute(xxRunnble);

没有返回值，如果不需要知道线程的结果就使用execute方法，性能会好很多。

八、如何关闭线程

1）es.shutdown(); 

不再接受新的任务，之前提交的任务等执行结束再关闭线程池。

2）es.shutdownNow();

不再接受新的任务，试图停止池中的任务再关闭线程池，返回所有未处理的线程list列表。

 

备注：

keepAliveTime举例说明：

核心线程数10，最大线程数30，keepAliveTime是3秒

随着任务数量不断上升，线程池会不断的创建线程，直到到达核心线程数10，就不创建线程了，

这时多余的任务通过加入阻塞队列来运行，

当超出阻塞队列长度+核心线程数时，

这时不得不扩大线程个数来满足当前任务的运行，这时就需要创建新的线程了（最大线程数起作用），上限是最大线程数30

那么超出核心线程数10并小于最大线程数30的可能新创建的这20个线程相当于是“借”的，如果这20个线程空闲时间超过keepAliveTime，就会被退出。