Java线程池

线程池

使用线程池的好处

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

ThreadPoolExector类简单介绍篇

ThreadPoolExector构造函数：

    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：核心线程数定义了线程池保有的最小线程数。
maximumPoolSize：线程池的最大线程数。
workQueue：任务队列，用来存储等待执行任务的队列。常见的阻塞队列有：

• ArrayBlockingQueue：基于数组结构的有界阻塞队列，按FIFO处理；
• LinkedBlockingQueue：基于链表结构的无界阻塞队列，按FIFO处理，吞吐量通常要高于ArrayBlockQueue；
• SynchronousQuene：一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQuene；

keepAliveTime：当线程数大于核心线程数时，多余的空闲线程存活的最长时间。
threadFactory：线程工厂，一般用来创建线程，默认即可，
handler：通过这个参数可以自定义拒绝策略，当提交的线程过多而不能及时处理时，我们可以指定策略来进行处理。ThreadPoolExecutor 已经提供了以下 4 种策略。

• CallerRunsPolicy：提交任务的线程自己去执行该任务。
• AbortPolicy：默认的拒绝策略，会 throws RejectedExecutionException。
• DiscardPolicy：直接丢弃任务，没有任何异常抛出。
• DiscardOldestPolicy：丢弃老的任务，其实就是把早进入工作队列的任务丢弃， 然后把新任务加入到工作队列。

ThreadPoolExecutor类的execute方法：

   // 存放线程池的运行状态 (runState) 和线程池内有效线程的数量 (workerCount)
   private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

    private static int workerCountOf(int c) {
        return c & CAPACITY;
    }

    private final BlockingQueue<Runnable> workQueue;

    public void execute(Runnable command) {
        // 如果任务为null，则抛出异常。
        if (command == null)
            throw new NullPointerException();
        // ctl 中保存的线程池当前的一些状态信息
        int c = ctl.get();

        //  下面会涉及到 3 步 操作
        // 1.首先判断当前线程池中之行的任务数量是否小于 corePoolSize
        // 如果小于的话，通过addWorker(command, true)新建一个线程，并将任务(command)添加到该线程中；然后，启动该线程从而执行任务。
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        // 2.如果当前之行的任务数量大于等于 corePoolSize 的时候就会走到这里
        // 通过 isRunning 方法判断线程池状态，线程池处于 RUNNING 状态并且队列可以加入任务，该任务才会被加入进去
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            // 再次获取线程池状态，如果线程池状态不是 RUNNING 状态就需要从任务队列中移除任务，并尝试判断线程是否全部执行完毕。同时执行拒绝策略。
            if (!isRunning(recheck) && remove(command))
                reject(command);
                // 如果当前线程池为空就新创建一个线程并执行。
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //3. 通过addWorker(command, false)新建一个线程，并将任务(command)添加到该线程中；然后，启动该线程从而执行任务。
        //如果addWorker(command, false)执行失败，则通过reject()执行相应的拒绝策略的内容。
        else if (!addWorker(command, false))
            reject(command);
    }

常见的线程池

1. newFixedThreadPool

一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
构造函数：

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

由构造函数可以看出，newFixedExecutor的构造函数中，corePoolSize和maximumPoolSize的大小均为nThreads，而且参数workQueue为LinkedBlockingQueue无界阻塞队列。

执行任务介绍：

1. 当前线程小于corePoolSize时，如果再来新的任务，则创建新的线程；
2. 当前线程等于corePoolSize时，如果再来新的任务，则会加入到LinkedBlockingQueue队列当中；
3. 线程池中的线程执行完 手头的任务后，会在循环中反复从 LinkedBlockingQueue 中获取任务来执行

2. SingleThreadExecutor

一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
构造函数：

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

从构造函数看出，corePoolSize和maximumPoolSize均为1。

3. newCachedThreadPool

一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
构造函数：

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

4. ScheduledThreadPoolExecutor

ScheduledThreadPoolExecutor 使用的任务队列 DelayQueue 封装了一个 PriorityQueue，PriorityQueue 会对队列中的任务进行排序，执行所需时间短的放在前面先被执行(ScheduledFutureTask 的 time 变量小的先执行)，如果执行所需时间相同则先提交的任务将被先执行(ScheduledFutureTask 的 squenceNumber 变量小的先执行)。
运行机制：

ScheduledThreadPoolExecutor 的执行主要分为两大部分：

• 当调用 ScheduledThreadPoolExecutor 的 scheduleAtFixedRate() 方法或者scheduleWirhFixedDelay() 方法时，会向 ScheduledThreadPoolExecutor 的 DelayQueue 添加一个实现了 RunnableScheduledFuture 接口的 ScheduledFutureTask 。
• 线程池中的线程从 DelayQueue 中获取 ScheduledFutureTask，然后执行任务。

ScheduledThreadPoolExecutor 为了实现周期性的执行任务，对 ThreadPoolExecutor 做了如下修改：

• 使用 DelayQueue 作为任务队列；
• 获取任务的方不同；
• 执行周期任务后，增加了额外的处理

ScheduledThreadPoolExecutor 执行周期任务的步骤：

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