Java线程池

最新推荐文章于 2024-07-13 22:56:10 发布

阳小林

最新推荐文章于 2024-07-13 22:56:10 发布

阅读量393

点赞数

分类专栏： Java 文章标签：线程池 threadpool

本文链接：https://blog.csdn.net/fjse51/article/details/59527466

版权

Java 专栏收录该内容

29 篇文章 0 订阅

订阅专栏

使用线程池的好处

1. 降低资源消耗。通过重复利用已创建的线程降低创建线程和销毁造成的消耗
2. 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
3. 提高线程的可管理性。

线程池的处理流程

这里写图片描述

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

ThreadPoolExcutore执行excutor方法的示意图

这里写图片描述

ThreadPoolExecutor执行executor方法分4中情况：

1. 当前运行的线程少于corePoolSize，则创新线程来执行任务，这一步骤需要获取全局锁
2. 如果运行的线程大于或等于corePoolSize，则将任务加入到BlockingQueue。
3. 如果无法将任务加入BlockingQueue，则创建新的线程来处理任务，这一步骤需要获取全局锁
4. 如果创建新线程将使当前运行的线程超出maximumPoolSize，任务将被拒绝，并调用RejectExecutionHandler.rejectExecution()方法

详细的拒绝规则如下：

AbortPolicy
为java线程池默认的阻塞策略，不执行此任务，而且直接抛出一个运行时异常，切记ThreadPoolExecutor.execute需要try catch，否则程序会直接退出。

DiscardPolicy
直接抛弃，任务不执行，空方法

DiscardOldestPolicy
从队列里面抛弃head的一个任务，并再次execute 此task。

CallerRunsPolicy
在调用execute的线程里面执行此command，会阻塞入口

ThreadPoolExecutor采取上述步骤的总体设计思想，是为了在执行executor方法时，尽可能地避免获取全局锁。在ThreadPoolSize完成预热之后（当前运行的线程数大于或者等于corePoolSize），几乎所有的executor方法调用都是执行步骤2，而步骤2不需要获取全局锁

源码实现

构造方法如下：

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

构造函数的参数详解如下：

int corePoolSize:线程池的基本大小，当提交一个任务到线程池时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，等到需要执行的任务数大于corePoolSize大小时，就不会再创建。如果调用了线程池的prestartAllCoreThreads()方法，线程池会提前创建并启动所有基本线程。
int maximumPoolSize:线程池最大数量。如果队列满了，并且已创建的线程数小于最大线程数，则线程会再创建新的线程执行任务。需要注意的是，如果使用了无界队列，那么这个参数就没有作用了
long keepAliveTime:线程活动保持时间。线程池的工作线程空闲后，保持存活的时间。所以如果任务很多，并且每个任务执行的时间比较短，可以调大时间，提高线程的利用率。
TimeUnit unit：线程活动保持时间的单位，可选的单位有天（DAYS）、小时（HOURS）、分钟（MINUTES）、秒（SECONDS）、毫秒（MILLISECODENS）、微秒（MICROSECONDS）、纳秒（NANOSECONDS）
BlockingQueue<Runnable> workQueue ：任务队列，用于保存等待执行的任务的阻塞队列。可选择的阻塞队列如下：

ArrayBlockingQueue:是一个基于数组结构的有界阻塞队列，按FIFO排序。

LinkedBlockingQueue:一个基于链表结构的阻塞队列，按FIFO排列，吞吐量高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用了这个队列

SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作必须等到另一线程调用移除操作，否则插入操作一直处于阻塞状态。吞吐量通常高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列。

ThreadFactory threadFactory：用于设置创建线程的工厂，可以通过线程工厂给每个创建出来的线程设置名字。使用开源框架guava提供的ThreadFactoryBuilder可以快速给线程池里的线程设置名字。
RejectedExecutionHandler handler：饱和策略。当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略出来提交的新任务。默认的AbortPolicy，表示无法处理新任务时抛出异常。也可以根据应用场景实现RejectedExecutionHandler接口自定义策略。

向线程池提交任务

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

向线程池提交任务的executor()方法

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();

            // 获取线程池控制状态
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) { // worker数量小于corePoolSize
            if (addWorker(command, true)) // 添加worker
                // 成功则返回
                return;
            // 不成功则再次获取线程池控制状态
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) { // 线程池处于RUNNING状态，将命令（用户自定义的Runnable对象）添加进workQueue队列
            // 再次检查，获取线程池控制状态
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command)) // 线程池不处于RUNNING状态，将命令从workQueue队列中移除
                // 拒绝执行命令
                reject(command);
            else if (workerCountOf(recheck) == 0) // worker数量等于0
                // 添加worker
                addWorker(null, false);
        }
        else if (!addWorker(command, false)) // 添加worker失败
            // 拒绝执行命令
            reject(command);
    }