java线程池之ThreadPoolExecutor介绍

我不是女神ヾ 2024-04-19 09:45 75阅读 0赞

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTQ1NzEz_size_16_color_FFFFFF_t_70][]

1 、线程池的优势

*  总体来说，线程池有如下的优势：
 *  （1）**降低资源消耗**。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
 *  （2）**提高响应速度**。当任务到达时，任务可以不需要等到线程创建就能立即执行。
 *  （3）**提高线程的可管理性**。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

2、线程池的使用

*  线程池的真正实现类是ThreadPoolExecutor，ThreadPoolExecutor继承抽象类AbstractExecutorService，AbstractExecutorService实现接口ExecutorService，ExecutorService又继承接口Executor
 *  流程：Executor--->ExecutorService--->AbstractExecutorService--->ThreadPoolExecutor
 *  ThreadPoolExecutor其构造方法有如下4种
 *      1、public ThreadPoolExecutor(int corePoolSize,
         int maximumPoolSize,
         long keepAliveTime,
         TimeUnit unit,
         BlockingQueue<Runnable> workQueue) {
         this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
        }
        
        2、public ThreadPoolExecutor(int corePoolSize,
         int maximumPoolSize,
         long keepAliveTime,
         TimeUnit unit,
         BlockingQueue<Runnable> workQueue,
         ThreadFactory threadFactory) {
         this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         threadFactory, defaultHandler);
        }
        
        3、public ThreadPoolExecutor(int corePoolSize,
         int maximumPoolSize,
         long keepAliveTime,
         TimeUnit unit,
         BlockingQueue<Runnable> workQueue,
         RejectedExecutionHandler handler) {
         this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), handler);
        }
        
        4、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;
        }
 *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTQ1NzEz_size_16_color_FFFFFF_t_70 1][]
 *  可以看到，其需要如下几个参数：
 *  **corePoolSize**（必需）：核心线程数。默认情况下，核心线程会一直存活，但是当将allowCoreThreadTimeout设置为true时，核心线程也会超时回收。
 *  **maximumPoolSize**（必需）：线程池所能容纳的最大线程数。当活跃线程数达到该数值后，后续的新任务将会阻塞。
 *  **keepAliveTime**（必需）：线程闲置超时时长。如果超过该时长，非核心线程就会被回收。如果将allowCoreThreadTimeout设置为true时，核心线程也会超时回收。
 *  **unit**（必需）：指定keepAliveTime参数的时间单位。常用的有：TimeUnit.MILLISECONDS（毫秒）、TimeUnit.SECONDS（秒）、TimeUnit.MINUTES（分）。
 *  **workQueue**（必需）：任务队列。通过线程池的execute()方法提交的Runnable对象将存储在该参数中。
 *  **threadFactory**（可选）：线程工厂。用于指定为线程池创建新线程的方式。
 *  **handler**（可选）：拒绝策略。当达到最大线程数时需要执行的饱和策略。
 *  线程池的使用流程如下
 *      // 创建线程池
        Executor threadPool = new ThreadPoolExecutor(CORE_POOL_SIZE,
         MAXIMUM_POOL_SIZE,
         KEEP_ALIVE,
         TimeUnit.SECONDS,
         sPoolWorkQueue,
         sThreadFactory);
        
        // 向线程池提交任务
        threadPool.execute(new Runnable() {
         @Override
         public void run() {
         ... // 线程执行的任务
         }
        });
        
        // 关闭线程池
        threadPool.shutdown(); // 设置线程池的状态为SHUTDOWN，然后中断所有没有正在执行任务的线程
        threadPool.shutdownNow(); // 设置线程池的状态为 STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表

3、 线程池的工作原理

*  下面来描述一下线程池工作的原理，同时对上面的参数有一个更深的了解。其工作原理流程图如下：
 *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTQ1NzEz_size_16_color_FFFFFF_t_70 2][]![format_png][]![format_png][]
 *  通过上图，相信大家已经对所有参数有个了解了。其实还有一点，在线程池中并没有区分线程是否是核心线程的。下面我们再对任务队列、线程工厂和拒绝策略做更多的说明。

4 、线程池的参数

*  4.1 任务队列（workQueue）
 *  任务队列是基于阻塞队列实现的，即采用生产者消费者模式，在Java中需要实现BlockingQueue接口。但Java已经为我们提供了7种阻塞队列的实现：

1.  **ArrayBlockingQueue**：一个由数组结构组成的有界阻塞队列（数组结构可配合指针实现一个环形队列）。
2.  **LinkedBlockingQueue**： 一个由链表结构组成的有界阻塞队列，在未指明容量时，容量默认为Integer.MAX\_VALUE。
3.  **PriorityBlockingQueue**： 一个支持优先级排序的无界阻塞队列，对元素没有要求，可以实现Comparable接口也可以提供Comparator来对队列中的元素进行比较。跟时间没有任何关系，仅仅是按照优先级取任务。
4.  **DelayQueue**：类似于PriorityBlockingQueue，是二叉堆实现的无界优先级阻塞队列。要求元素都实现Delayed接口，通过执行时延从队列中提取任务，时间没到任务取不出来。
5.  **SynchronousQueue**： 一个不存储元素的阻塞队列，消费者线程调用take()方法的时候就会发生阻塞，直到有一个生产者线程生产了一个元素，消费者线程就可以拿到这个元素并返回；生产者线程调用put()方法的时候也会发生阻塞，直到有一个消费者线程消费了一个元素，生产者才会返回。
6.  **LinkedBlockingDeque**： 使用双向队列实现的有界双端阻塞队列。双端意味着可以像普通队列一样FIFO（先进先出），也可以像栈一样FILO（先进后出）。
7.  **LinkedTransferQueue**： 它是ConcurrentLinkedQueue、LinkedBlockingQueue和SynchronousQueue的结合体，但是把它用在ThreadPoolExecutor中，和LinkedBlockingQueue行为一致，但是是无界的阻塞队列。

*  注意有界队列和无界队列的区别：如果使用有界队列，当队列饱和时并超过最大线程数时就会执行拒绝策略；而如果使用无界队列，因为任务队列永远都可以添加任务，所以设置maximumPoolSize没有任何意义。

5 、功能线程池（也就是帮我们按照一定的功能封装好的线程池）

嫌上面使用线程池的方法太麻烦？其实Executors已经为我们封装好了4种常见的功能线程池，如下：

*  定长线程池（FixedThreadPool）
 *  定时线程池（ScheduledThreadPool ）
 *  可缓存线程池（CachedThreadPool）
 *  单线程化线程池（SingleThreadExecutor）

6、使用方法

*  6.1定长线程池（FixedThreadPool）
 *   **特点**： 只有核心线程，线程数量固定，执行完立即回收，可控制线程最大并发数，超出的限线程会在队列中等待。
 *  **应用场景**：控制线程最大并发数。
 *      public static void main(String[] args) {
                    ExecutorService executorService = Executors.newFixedThreadPool(3);
                    for (int i=0;i<5; i++){
                        executorService.execute(new Runnable() {
                            @Override
                            public void run() {
                                //执行方法
                            }
                        });
                    }
                    executorService.shutdown();
                }
        源码：
        public static ExecutorService newFixedThreadPool(int nThreads) {
                return new ThreadPoolExecutor(nThreads, nThreads,
                                              0L, TimeUnit.MILLISECONDS,
                                              new LinkedBlockingQueue<Runnable>());
            }
 *  6.2可缓存线程池（CachedThreadPool）  
 *  **特点**：无核心线程，非核心线程数量无限，执行完闲置60s后回收，当执行第二个任务的时候如果第一个任务已经完成会复用第一个任务的线程，而不用重新创建
 *  **应用场景**：执行大量、耗时少的任务。
 *      public static void main(String[] args) {
                    ExecutorService executorService = Executors.newCachedThreadPool();
                    for (int i=0; i<5; i++){
                        executorService.execute(new Runnable() {
                            @Override
                            public void run() {
                                //执行任务
                            }
                        });
                    }
                    executorService.shutdown();
                }
        源码：
        public static ExecutorService newCachedThreadPool() {
                return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                              60L, TimeUnit.SECONDS,
                                              new SynchronousQueue<Runnable>());
            }
 *  6.3定时线程池（ScheduledThreadPool ）
 *  **特点**：核心线程数量固定，非核心线程数量无限，执行完闲置10ms后回收，任务队列为延时阻塞队列。
 *  **应用场景**：执行定时或周期性的任务。
 *      public static void main(String[] args) {
              // 1. 创建 定时线程池对象 & 设置线程池线程数量固定为5
               ScheduledExecutorService executorService = Executors.newScheduledThreadPool(5);
              // 2. 创建好Runnable类线程对象 & 需执行的任务
               Runnable task =new Runnable(){
                   public void run() {
                      System.out.println("执行任务啦");
                    }
                };
              // 3. 向线程池提交任务，// 延迟1s后执行任务
              executorService.schedule(task, 1, TimeUnit.SECONDS);
              // 延迟 10ms后、每隔1000ms执行任务 
              executorService.scheduleAtFixedRate(task,10,1000,TimeUnit.MILLISECONDS);
                     
        }
        
        源码：
         public ScheduledThreadPoolExecutor(int corePoolSize) {
            super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
                    new DelayedWorkQueue());
        }
    
    6.4单线程化线程池（SingleThreadExecutor）
 *  **特点**：只有1个核心线程，无非核心线程，执行完立即回收，任务队列为链表结构的有界队列。
 *  **应用场景**：不适合并发但可能引起IO阻塞性及影响UI线程响应的操作，如数据库操作、文件操作等。但是可以保证多个线程（任务）按照顺序执行（多个线程顺序执行也可以用线程的join方法来实现）

*      public static void main(String[] args) {
                    ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
                    for (int i=0;i<5; i++){
                        singleThreadExecutor.execute(new Runnable() {
                            @Override
                            public void run() {
                                //执行方法
                            }
                        });
                    }
                    singleThreadExecutor.shutdown();
                }
        源码：
         public static ExecutorService newSingleThreadExecutor() {
                return new FinalizableDelegatedExecutorService
                    (new ThreadPoolExecutor(1, 1,
                                            0L, TimeUnit.MILLISECONDS,
                                            new LinkedBlockingQueue<Runnable>()));
            }

7、总结

*  Executors的4个功能线程池虽然方便，但现在已经不建议使用了，而是建议直接通过使用ThreadPoolExecutor的方式，建议我们自定义线程，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
 *  当然如果你用的是idea开发工具的话，工具也会提示你最好手动创建线程池而不是使用已经封装好的
 *  ![20190916194531141.png][]

8、ThreadPoolExecutor与ThreadPoolTaskExecutor区别

*  ThreadPoolTaskExecutor是spring core包中的，而ThreadPoolExecutor是JDK中的JUC。ThreadPoolTaskExecutor是对ThreadPoolExecutor进行了封装处理。
 *  ThreadPoolTaskExecutor源码中有一个用来初始化threadPoolExecutor的方法
 *  可以用ThreadPoolTaskExecutor重写spring的异步注解@Async，使用自定义的线程池，而不是默认的
 *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTQ1NzEz_size_16_color_FFFFFF_t_70 3][]![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTQ1NzEz_size_16_color_FFFFFF_t_70 4][]
 *  两者类图结构
 *  ![format_png 1][]![format_png 2][]
 *  [参考1][1]，[参考2][2]
 *  [论如何优雅的自定义ThreadPoolExecutor线程池][ThreadPoolExecutor]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTQ1NzEz_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/aa95629882a9416cb5d6076de20409ce.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTQ1NzEz_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/63732006dbf34fa48b04957d1b4059ef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTQ1NzEz_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20190916190259134.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTQ1NzEz,size_16,color_FFFFFF,t_70
[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9lUVB5QmZmWWJ1ZWZ6ZDViS1VQU2RJc2JTeUppYkpuSkxENmliZjlNMjk1cVh4WWQza2Zvc2ljVUx5bjhySVlFN1NObE56VUh0aHBqT3loNE56YkxXaWJKeFEvNjQwP3d4X2ZtdD1wbmcmdHA9d2VicCZ3eGZyb209NSZ3eF9sYXp5PTEmd3hfY289MQ?x-oss-process=image/format,png
[20190916194531141.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/900f58a4d9654b02adee87ca0085c541.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTQ1NzEz_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20190916200529122.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTQ1NzEz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTQ1NzEz_size_16_color_FFFFFF_t_70 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/4c64e19255a94f2284edcdecefc6847b.png
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9hc2sucWNsb3VkaW1nLmNvbS9odHRwLXNhdmUveWVoZS0zNzMzMDY3L2F0cXNmejJoMXYucG5nP2ltYWdlVmlldzIvMi93LzE2MjA?x-oss-process=image/format,png
[format_png 2]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9hc2sucWNsb3VkaW1nLmNvbS9odHRwLXNhdmUveWVoZS0zNzMzMDY3L3RpdnA0dzR2dmQucG5nP2ltYWdlVmlldzIvMi93LzE2MjA?x-oss-process=image/format,png
[1]: https://www.toutiao.com/a6716807082915398152/?tt_from=weixin&utm_campaign=client_share&wxshare_count=1&timestamp=1568628202&app=news_article&utm_source=weixin&utm_medium=toutiao_android&req_id=20190916180322010020047015382A1C4D&group_id=6716807082915398152
[2]: https://cloud.tencent.com/developer/article/1408125
[ThreadPoolExecutor]: https://www.cnblogs.com/wang-meng/p/10163855.html