8.线程池用过吗? ThreadPoolExecutor谈谈你的理解?

说明

本文目录前是相关视频的名字和具体视频中思维导图的名字

题目

8.线程池用过吗? ThreadPoolExecutor谈谈你的理解?

说说线程池的底层工作原理?

45 Callable接口

package blockingqueue7;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;


class MyThread implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName()+"********come in Callable");
        return 1024;
    }
}

/**
 * @author CSDN@日星月云
 * @date 2022/10/10 20:42
 * java
 * 多线程，第3种获得多线程的方式
 */
public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //两个线程，一个main线程，一个AAfutureTask
        //FutureTask(Callable<V> callable)
        FutureTask<Integer> futureTask =new FutureTask<>(new MyThread());

        new Thread(futureTask,"AA").start();
        new Thread(futureTask,"BB").start();//BB复用


        while (!futureTask.isDone());

        int result01=100;
        int result02=futureTask.get();//要求获得Callable线程的计算结果，如果没有计算完成就要去强求，会导致堵塞，值得计算完成

        System.out.println("****result"+(result01+result02));

    }
}

46 线程池使用及优势

为什么用线程池，优势

线程池做的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了大数量超出数量的线程排队等候，等其它线程执行完毕，再从队列中取出任务来执行。

他的主要特点为:线程复用:控制最大并发数;管理线程。

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

47 线程池3个常用方式

线程池如何使用?

架构说明

Java中的线程池是通过Executor框架实现的，该框架中用到了Executor，Executors,ExecutorService，ThreadPoolExecutor这几个类。

编码实现

了解

• Executors.newScheduledThreadPool()
• java8新出——Executors.newWorkStealinPool(int)——java8新增,使用目前机器上可用的处理器作为它的并行级别

重点

Executors.newFixedThreadPool(int)
执行长期的任务，性能好很多

Executors.newSingleThreadExecutor()

一个任务一个任务执行的场景

Executors.newCachedThreadPool()

适用:执行很多短期异步的小程序或者负载较轻的服务

48 线程池7大参数入门简介

ThreadPoolExecutor

线程池的几个重要参数介绍?

七个参数

49 线程池7大参数深入介绍

1.corePoolSize:线程池中的常驻核心线程数

• 1在创建了线程池后，当有请求任务来之后，就会安排池中的线程去执行请求任务，近似理解为今日当值线程

• 2当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中;

2.maximumPoolSize:线程池能够容纳同时执行的最大线程数，此值必须大于等于1
corePoolSize和workQueue满了

3.keepAliveTime:多余的空闲线程的存活时间。
当前线程池数量超过corePoolSize时，当空闲时间达到keepAliveTime值时，
多余空闲线程会被销毁直到只剩下corePoolSize个线程为止

4.unit: keepAliveTime的单位。

5.workQueue:任务队列，被提交但尚未被执行的任务。

6.threadFactory:表示生成线程池中工作线程的线程工厂，用于创建线程一般用默认的即可。

7.handler:拒绝策略，表示当队列满了并且工作线程大于等于线程池的最大线程数(maximumPoolSize)时如何来指定

以顾客去银行办理业务为例，谈谈线程池的底层工作原理

1. 最开始假设来了两个顾客，因为corePoolSize为2，因此这两个顾客直接能够去窗口办理
2. 后面又来了三个顾客，因为corePool已经被顾客占用了，因此只有去候客区，也就是阻塞队列中等待
3. 后面的人又陆陆续续来了，候客区可能不够用了，因此需要申请增加处理请求的窗口，这里的窗口指的是线程池中的线程数，以此来解决线程不够用的问题
4. 假设受理窗口已经达到最大数，并且请求数还是不断递增，此时候客区和线程池都已经满了，为了防止大量请求冲垮线程池，已经需要开启拒绝策略
5. 临时增加的线程会因为超过了最大存活时间，就会销毁，最后从最大数削减到核心数

package threadpool8;

import java.util.concurrent.*;

/**
 * @author CSDN@日星月云
 * @date 2022/10/11 19:20
 */
public class T1 {
    public static void main(String[] args) {
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                5,
                100L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3),//等候区
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        try {
            for (int i = 1; i <= 8; i++) { //模拟6个顾客来办理业务，受理窗口max只有5个
                final int tmpI = i;
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "号窗口，”+“服务顾客" + tmpI);
                    try {
                        TimeUnit.SECONDS.sleep(4);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
    }
}

pool-1-thread-1号窗口，”+“服务顾客1
pool-1-thread-5号窗口，”+“服务顾客8
pool-1-thread-2号窗口，”+“服务顾客2
pool-1-thread-3号窗口，”+“服务顾客6
pool-1-thread-4号窗口，”+“服务顾客7
pool-1-thread-2号窗口，”+“服务顾客3
pool-1-thread-3号窗口，”+“服务顾客4
pool-1-thread-5号窗口，”+“服务顾客5

总结：
corePoolSize今日当值，
workQueue等候区
当今日当值与等候区满员了，就会开通所有的窗口maximumPoolSize
如果业务量仍然增多，大堂经理采取拒绝策略handler
如果业务量慢慢减少，keepAliveTime(unit)内没有增多，就会缩减窗口直到今日当值

50 线程池底层工作原理

说说线程池的底层工作原理？

1. 在创建了线程池后，等待提交过来的任务请求
2. 当调用execute()方法添加一个请求任务时，线程池会做出如下判断
   1. 如果正在运行的线程池数量小于corePoolSize，那么马上创建线程运行这个任务
   2. 如果正在运行的线程数量大于或等于corePoolSize，那么将这个任务放入队列
   3. 如果这时候队列满了，并且正在运行的线程数量还小于maximumPoolSize，那么还是创建非核心线程like运行这个任务；
   4. 如果队列满了并且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会启动饱和拒绝策略来执行
3. 当一个线程完成任务时，它会从队列中取下一个任务来执行
4. 当一个线程无事可做操作一定的时间(keepAliveTime)时，线程池会判断：
   如果当前运行的线程数大于corePoolSize，那么这个线程就被停掉
   所以线程池的所有任务完成后，它会最终收缩到corePoolSize的大小

---