重学多线程（四）—— 线程池

最新推荐文章于 2023-09-06 18:01:31 发布

懋为

最新推荐文章于 2023-09-06 18:01:31 发布

阅读量213

点赞数 1

分类专栏：重学多线程

本文链接：https://blog.csdn.net/tjreal/article/details/79007947

版权

重学多线程专栏收录该内容

11 篇文章 0 订阅

订阅专栏

前言

Java中的线程池是运用场景最多的并发框架，合理的使用线程池能够有如下好处：

降低资源消耗
通过重复利用已创建的线程降低线程创建和销毁造成的消耗；
提高响应速度
当任务到达时，任务可以不需要等到线程创建就能立即执行；
提高线程的可管理性
线程是稀缺资源，使用线程池可以进行统一分配、优化和监控；

ThreadPoolExecutor类

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), defaultHandler);
}

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, defaultHandler);
}

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), handler);
}

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

构造器中各个参数的含义：

corePoolSize，该线程池中核心线程数最大值；
maximumPoolSize，该线程池中线程总数最大值；
keepAliveTime，表示线程没有任务执行时最多保持多久时间会终止；
unit：参数keepAliveTime的时间单位，有7种取值；
workQueue：一个阻塞队列，用来存储等待执行的任务；
threadFactory：线程工厂，主要用来创建线程；
handler：表示当拒绝处理任务时的策略。

拒绝策略：

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

线程池处理过程

ThreadPoolExecutor通过调用execute(Runnable)方法处理任务，execute方法如下：

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
            reject(command);
    }

处理过程大概分为如下四步：

如果当前运行的线程少于corePoolSize，则创建新线程来执行任务；
如果当前的线程等于或者大于corePoolSize，则将任务加入workQueue；
如果无法将任务加入workQueue，则创建新的线程来处理任务；
如果创建新线程将使当前运行的线程数超过maximumPoolSize，任务将被拒绝，并调用相应的拒绝策略。

Future接口

ThreadPoolExecutor有两个方法实现往线程池提交任务，分别是execute()和sumbit()方法。前者可以用来提交不需要返回值的任务；后者用于提交需要返回值的任务，返回一个实现Future接口的对象。

查看submit方法的返回值为一个Future，实际上这个Futrue为FutureTask实例，通过此实例，调用get方法，可以阻塞当前线程，直到任务运行完毕，返回结果。

FutureTask状态转换关系如下：

    private static final int NEW          = 0;
    private static final int COMPLETING   = 1;
    private static final int NORMAL       = 2;
    private static final int EXCEPTIONAL  = 3;
    private static final int CANCELLED    = 4;
    private static final int INTERRUPTING = 5;
    private static final int INTERRUPTED  = 6;

NEW -> COMPLETING -> NORMAL
NEW -> COMPLETING -> EXCEPTIONAL
NEW -> CANCELLED
NEW -> INTERRUPTING -> INTERRUPTED

整个调用链条如下所示：

worker thread -> futureTask.run() -> callable.call() -> task.run()

如果提交的是Callable任务，则只有前面三个调用，具体执行过程如下：

向线程池submit一个Callable任务(Runnable也会被转为Callable)，这时候Callable被传入一个FutureTask实例中；
线程池使用一个线程，执行这个 FutureTask 任务；
线程执行任务过程比较简单，最终会调用Callable.call()或者是 Runnable.run()方法，然后得到一个结果，把结果存储在FutureTask实例的outcome属性中，同时把状态修改为NORMAL，表明任务已经执行完毕，可以获取结果了；
当有多个线程调用FutureTask.get方法，由于任务未执行结束，这时候，线程都将被阻塞休眠，FutureTask中有一个栈，用于存放等待线程，栈顶指针为 FutureTask.waiters引用，当任务执行完毕后，会迭代唤醒整个栈中的线程，这时候，各个线程都将被唤醒，并且可以顺利拿到任务的执行结果(执行结果存于 FutureTask.outcome)。