JAVA-线程池

淡淡的烟草味﹌ 2023-10-12 13:27 3阅读 0赞

### **1、什么是线程池？** ###

> **线程池**：一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。

### **2、使用线程池的好处:** ###

> 1.  降低资源消耗
> 2.  提高响应速度
> 3.  方便管理

### 3、线程池实现“线程复用”的原理图： ###

![cb32e71b807b4576a20f9b99d44dd24c.jpg][]

> 1.  提交线程任务时，线程池会检测核心线程池是否已满（即当前线程数是否小于核心线程数）？如果核心线程池不满就会创建一个核心线程去执行刚刚提交的线程任务
> 2.  如果检测到核心线程池已满，再看任务队列是否已满？任务队列未满时将任务添加到队列，等待核心线程来执行；
> 3.  任务队列已满，会检测线程池是否已满（即有没有达到线程池的最大线程数）？假设线程池不满，就会创建非核心线程执行任务了。
> 4.  假设线程池已满，就会按策略处理无法执行的任务（执行拒绝线程策略）。

### 4、创建线程池 ###

Executors 创建线程池的三大方法如下：

ExecutorService service = Executors.newSingleThreadExecutor();//单个线程
      /*public static ExecutorService newSingleThreadExecutor() {
            return new FinalizableDelegatedExecutorService
                (new ThreadPoolExecutor(1, 1,
                                        0L, TimeUnit.MILLISECONDS,
                                        new LinkedBlockingQueue<Runnable>()));
        }*/
      ExecutorService service = Executors.newFixedThreadPool(5);//创建一个固定的线程池的大小
      /* public static ExecutorService newFixedThreadPool(int nThreads) {
            return new ThreadPoolExecutor(nThreads, nThreads,
                                          0L, TimeUnit.MILLISECONDS,
                                          new LinkedBlockingQueue<Runnable>());
        }*/
      ExecutorService service = Executors.newCachedThreadPool();//缓存线程池，可伸缩的
      /*public static ExecutorService newCachedThreadPool() {
            return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                          60L, TimeUnit.SECONDS,
                                          new SynchronousQueue<Runnable>());
        }*/

阿里巴巴开发手册不允许Executors 创建线程池，主要原因如下：![7a45ba5437b44d8686d2d2e301eddf6e.png][]

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

**对ThreadPoolExecutor 参数的理解**（银行办理业务）：

> 1.  **核心线程池大小（corePoolSize）**：表示银行一般情况下开设的窗口（线程数）。当然，对于线程池来说，最开始肯定不是满核心线程数的，核心线程是一个一个创建的。
> 2.  **阻塞队列（workQueue）**：相当于银行的侯客区。线程任务数量超过核心线程数，进入任务阻塞队列
> 3.  **最大线程池大小（maximumPoolSize）**：银行某一时间段所能接受的办理业务的最大人数。当各个窗口的都满，且排队人数已满，这个时候就会临时开设新的服务窗口（非核心线程）处理业务。即当线程任务数大于 阻塞队列大小 + 核心线程数的数量时，创建非核心线程执行任务，直至达到最大线程池的大小 （最大处理线程数=最大线程数+阻塞队列大小）
> 4.  **非核心线程的存活时间（keepAliveTime）**：银行开设的临时窗口当一段时间发现没有人来办理业务就会撤销掉，这个时间就是非核心线程的存活时间。
> 5.  **拒绝策略（handler）**：达到最大处理线程数还增加的话就会使用拒绝策略！

ExecutorService threadPool =
     new ThreadPoolExecutor(3, //核心线程池大小
                            5, //最大并发数
                            10, //超时时间
                            TimeUnit.SECONDS, //时间单位
                            new LinkedBlockingQueue<>(),//线程等候队列
                            Executors.defaultThreadFactory(), //线程创建工厂
                            new ThreadPoolExecutor.DiscardOldestPolicy());//拒绝策略

### 5、最大线程到底应该如何定义？ ###

（1）CPU密集型 几核,就是几,可以保证CPU的效率最高  
java获取cpu核数的方法：

Runtime.getRuntime().availableProcessors()

（2）IO 密集型 判断程序中十分耗I/O的线程, 大于两倍

###  ###

### **6、四种默认的拒绝策略** ###

> 1.  **new ThreadPoolExecutor.AbortPolicy()**  超出最大处理线程抛出异常（最大处理线程数=最大线程数+阻塞队列大小）
> 2.  **new ThreadPoolExecutor.CallerRunsPolicy()** 从哪个线程创建就由那个线程执行（如main线程创建，就在main线程执行）
> 3.  **new ThreadPoolExecutor.DiscardPolicy()** 队列满了不会抛出异常
> 4.  **new ThreadPoolExecutor.DiscardOldestPolicy()**  尝试去和第一个竞争，也不会抛出异常

[cb32e71b807b4576a20f9b99d44dd24c.jpg]: https://img-blog.csdnimg.cn/cb32e71b807b4576a20f9b99d44dd24c.jpg
[7a45ba5437b44d8686d2d2e301eddf6e.png]: https://img-blog.csdnimg.cn/7a45ba5437b44d8686d2d2e301eddf6e.png