JUC之ThreadPool

很久没写学习笔记了，惭愧！在公司负责App后台项目，最近客户端的小哥哥嫌App首页加载太慢了，让我进一步优化，看到项目里面其他模块有用线程池，之前不了解，就学习了下，用线程池异步去执行一些任务，再加上redis做缓存应该能更提升性能吧。

线程池带来的好处

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

线程池的实现原理

输入图片说明

线程池的处理流程如下：

线程池判断核心线程池里的线程是否都在执行任务。如果不是，则创建一个新的工作线程来执行任务，。如果核心线程池里的线程都在执行任务，则进入下一个流程。
线程池判断工作队列是否已经嘛呢。如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下个流程。
线程池判断线程池里的线程是否都处于工作状态。如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给饱和策略来处理这个任务。

看下主要的一个构造器：

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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;

参数说明

corePoolSize

代表核心线程个数，当一个任务提交到线程池时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，等到需要执行的任务数大于线程池的基本大小时，就不会再创建。如果调用了线程池的prestartAllCoreThreads()方法，线程池会提前创建并启动所有基本线程。

maximumPoolSize

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

keepAliveTime

当线程数大于核心线程数时，终止前多余的空闲线程等待新任务的最长时间。比如说线程池中最大的线程数为50，而其中只有40个线程任务在跑，相当于有10个空闲线程，这10个空闲线程不能让他一直在开着，因为线程的存在也会特别好资源的，所有就需要设置一个这个空闲线程的存活时间，这么解释应该就很清楚了。

TimeUnit

keepAliveTime的单位

BlockingQueue

阻塞队列（任务队列），存放execute提交的实现了Runnable接口任务的任务队列

可以选择以下几个阻塞队列

ArrayBlockingQueue: 是一个基于数组结构的有界阻塞队列，按FIFO原则对元素进行排序。
LinkedBlockingQueue: 一个基于链表结构的阻塞队列，按FIFO排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用了这个队列。
SynchronousQueue: 一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列。
PriorityBlockingQueue: 一个具有优先级别的无线阻塞队列。

ThreadFactory

创建线程的线程工厂类

RejectedExecutionHandler

饱和策略，使用有界队列的时候，如果队列满了，任务添加到线程池的时候就会有问题，所以有相应的拒绝策略。

在JDK1.5中提供了以下四种策略

AbortPolicy: 直接抛出异常。
CallerRunsPolicy: 只用调用者所在线程来运行任务。
DiscardOldeestPolicy: 丢弃队列里最近的一个任务，并执行当前任务。
DiscardPolicy: 不处理，丢弃掉。

向线程池提交任务

提交单个任务的两个方法

execute()
submit()

execute()方法用于提交不需要返回值得任务，所以无法判断任务是否执行成功。 submit()方法用于提交需要返回值的任务。线程池会返回一个future类型的对象，通过这个future类型的对象可以判断任务是否执行完成，并且可以通过future的get()方法来获取返回值，get()方法会阻塞当前线程直到任务执行完成，而使用get(long timeout, TimeUnit unit)方法则会阻塞当前线程指定时间后返回，有可能线程并没有执行完成。

提交一组任务的方法

invokeAny()

一旦有1个任务正常完成(执行过程中没有抛异常)，线程池会终止其他未完成的任务。

如果提交的任务列表中，没有1个正常完成的任务，那么调用invokeAny会抛异常，究竟抛的是哪儿个任务的异常，无关紧要。

invokeAny()返回最先正常完成(without throwing exception)的任务直接结果；一旦有任务正常完成或者调用出现异常，线程池都会终止正在运行或等待运行(tasks that have not completed are cancelled)的任务。

invokeAll()

对于invokeAll(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit)，给定的超时期满，还没有完成的任务会被取消，即Future.isCancelled()返回true；在超时期之前，无论是正常完成还是异常终止的任务，Future.isCancelled()返回false。

如果线程在等待invokeAll()执行完成的时候,被中断,会抛出InterruptedException，此时线程池会终止没有完成的任务,这主要是为了减少资源的浪费。

ExecutorService.invokeAll()方法产生了异常，线程池中还没有完成的任务会被取消执行

关闭线程池

shutdown()和shutdownNow()

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

区别：

shutdownNow首先将线程池的状态设置为STOP，然后尝试停止所有正在执行的或者暂停任务的线程并返回等待执行任务的列表。

shutdown只是将线程池的状态设置成为SHUTDOWN状态，然后中断所有没有正在执行任务的线程。

只要调用了这两个关闭方法中的任意一个，isShutdown方法就会返回true。当所有的任务都已经关闭后，才表示线程池关闭成功，这时调用isTerminated方法会返回true。至于应该调用哪一种方法来关闭线程池，应该由提交到线程池的任务特性决定，通常调用shutdown方法来关闭线程，如果任务不一定要执行完，则可以调用shutdownNow方法。

合理的配置线程池

要想合理地配置线程池，就必须首先分析任务特性，可以从以下几个角度来分析。

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

CPU密集型任务应该配置尽可能小的线程，如配置 N+1个线程池（N代表CPU个数）。

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

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

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

优先级不同的任务可以使用优先队列（PriorityBlockingQueue）来处理，它可以让优先级高的任务先处理，注意：如果一直有优先级高的任务提交到队列里面，那么优先级低的任务可能永远不能执行。

执行时间不同的任务可以交给不同规模的线程池来处理，或者可以使用优先队列，让执行时间段的任务线先执行。

依赖数据库连接池的任务，因为线程提交SQL后需要等待数据库返回结果，等待时间越长，则CPU空闲时间就越长，那么线程数应该设置得越大，这样才能更好地利用CPU。

建议使用有界队列。

猜你喜欢