线程池的3个常用方式

最新推荐文章于 2022-08-16 09:59:41 发布

NotRepent

最新推荐文章于 2022-08-16 09:59:41 发布

阅读量166

点赞数

分类专栏：线程文章标签： java

本文链接：https://blog.csdn.net/NotRepent/article/details/125213399

版权

线程专栏收录该内容

5 篇文章 0 订阅

订阅专栏

本文介绍了Java中三种线程池的使用方式：固定长度线程池（处理定长并发）、单线程化线程池（保证任务顺序执行）和可缓存线程池（动态调整线程）。通过示例展示了ExecutorService在不同场景下的应用，以及它们各自的特性。

摘要由CSDN通过智能技术生成

1.为什么要用线城池，优势？

2.应用方式

package com.thread;


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 *Java中的线程池是通过 Executor来实现的，该框架用到了Executor，Executors,ExecutorService,ThreadPoolExecutor
 * 这几个类
 *
 *
 * 线程池的3种应用方式
 *
 */
public class MyThreadPoolDemo {
    public static void main(String[] args) {

        /**
         *
         *     public static ExecutorService newFixedThreadPool(int nThreads) {
         *         return new ThreadPoolExecutor(nThreads, nThreads,
         *                                       0L, TimeUnit.MILLISECONDS,
         *                                       new LinkedBlockingQueue<Runnable>());
         *     }
         *
         * 主要特点：
         * 1.创建一个定长的线程池，可控制最大并发数，超出的线程会在队列中等待
         *
         * 2.newFixedThreadPool创建线程中 coolPoolSize 和 maxiMumPoolSize 值是相等的它使用的LinkedBlockQueue
         *
         */
        ExecutorService executorService = Executors.newFixedThreadPool(5); //一池5个线程处理


        /**
         *    public static ExecutorService newSingleThreadExecutor() {
         *         return new FinalizableDelegatedExecutorService
         *             (new ThreadPoolExecutor(1, 1,
         *                                     0L, TimeUnit.MILLISECONDS,
         *                                     new LinkedBlockingQueue<Runnable>()));
         *     }
         *
         *    主要特点：
         *    1.创建一个单一线程化的线程池，它只会用唯一的工作线程 来执行任务，保证所有的任务按照指定的线程来执行
         *
         *    2.newSingleThreadExecutor 中将 coolPoolSize 和 maxiMumPoolSize都设置为1 它使用的是 LinkedBlockingQueue
         */
        ExecutorService executorService1 = Executors.newSingleThreadExecutor();//一池一个线程

        /**
         *
         *  public static ExecutorService newCachedThreadPool() {
         *         return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
         *                                       60L, TimeUnit.SECONDS,
         *                                       new SynchronousQueue<Runnable>());
         *     }
         *
         *   主要特点：
         *   1.创建一个可以缓存的线程池，如果线程长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程
         *   2.newCachedThreadPool 将coolPoolSize 设置成 0 将maxiMumPoolSize设置为 Integer.MAX_VALUE
         *   使用了SynchronousQueue 也就是说 来了任务就创建线程运行 当空闲60S后 就销毁线程
         *
         */
        ExecutorService executorService2 = Executors.newCachedThreadPool();//一池N个线程

        //10个用户来创办业务,每一个用户就是来自外部的请求线程
         try {
             for (int i = 1; i <=10 ; i++) {
                 executorService.execute(()->{
                     System.out.println(Thread.currentThread().getName()+"\t 办理业务");
                 });
//                  try {
//                        TimeUnit.MILLISECONDS.sleep(200);
//                       } catch (Exception e) {
//                        e.printStackTrace();
//                    }
             }
              } catch (Exception e) {
               e.printStackTrace();
           }finally {
             executorService.shutdown();
         }


    }
}

executorService的输出结果

pool-1-thread-1   办理业务
pool-1-thread-3   办理业务
pool-1-thread-2   办理业务
pool-1-thread-2   办理业务
pool-1-thread-5   办理业务
pool-1-thread-3   办理业务
pool-1-thread-1   办理业务
pool-1-thread-4   办理业务
pool-1-thread-5   办理业务
pool-1-thread-2   办理业务

executorService1的输出结果

pool-1-thread-1   办理业务
pool-1-thread-1   办理业务
pool-1-thread-1   办理业务
pool-1-thread-1   办理业务
pool-1-thread-1   办理业务
pool-1-thread-1   办理业务
pool-1-thread-1   办理业务
pool-1-thread-1   办理业务
pool-1-thread-1   办理业务
pool-1-thread-1   办理业务

executorService2的输出结果

pool-1-thread-1   办理业务
pool-1-thread-4   办理业务
pool-1-thread-3   办理业务
pool-1-thread-2   办理业务
pool-1-thread-7   办理业务
pool-1-thread-6   办理业务
pool-1-thread-5   办理业务
pool-1-thread-8   办理业务
pool-1-thread-8   办理业务
pool-1-thread-1   办理业务