多线程编程设计模式(单例,阻塞队列,定时器,线程池)（四）-阿里云开发者社区

多线程编程设计模式(单例,阻塞队列,定时器,线程池)（三）+https://developer.aliyun.com/article/1413588

3.java标准库内部的线程池

1.基本概念

java标准库内部其实实现了线程池,线程池被封装成了一个类ThreadPoolExecutor

创建出一个线程池

// 向上转型
        ExecutorService service = Executors.newCachedThreadPool();

\ \ 此处线程池的创建并没有通过常规的new关键字创建,而是调用了Executors内部的一个方法来创建线程池对象,这种创建对象的方式我们称之为工厂模式,工厂模式也是设计模式的一种,工厂模式的存在主要是为了解决构造方法缺陷,有时候我们对一个类的实现希望其有多种方式,而实现需要通过构造方法来创建,由于构造方法的方法名只能是类名,这就带来了一些使用上的局限性,请看下图

同理,对于ThreadPoolExecutor的创建来说,他也有很多种实现方式,为了更好的调用,此处就采用工厂模式进行创建(可以将对象的创建方法总结为以下两种)

2.ThreadPoolExecutor的实现方式

ThreadPoolExecutor一般有四种实现方式:

前两种实现方式比较常用,后两种实现方式不常用,了解即可

3.ThreadPoolExecutor的核心方法

核心方法就两个:

构造方法
任务提交方法

1.任务提交

任务提交方法比较简单,创建好ThreadPoolExecutor对象之后使用submit方法进行任务的提交,交给线程池内部线程去执行提交的任务

service.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("任务提交");
            }
        });

更重要的是ThreadPoolExecutor的构造方法,这也是面试常考的!!!

2.构造方法(重点)

进入到javase的标准文档,查看ThreadPoolExecutor的构造方法

一共有四个构造方法,但实际上前三种都是简化版本,省去了一些参数,第四种是最全的构造方法,这里重点掌握第四种方法

依次来看第四种构造方法的参数

**int corePoolSize, int maximumPoolSize**

corePoolSize:核心线程的数目

maximumPoolSize:线程池内部最多持有的线程数目

什么是核心线程呢?对于一个线程池来说,其内部存储的线程分为两类:

核心线程
非核心线程

核心线程是一个线程池内部始终持有的线程,无论任务有多少,核心线程的数目始终固定不变;非核心线程不是线程池始终持有的,可以根据要执行任务的多少添加或删除,当任务多时,就新建几个非核心线程去应对高任务量,任务少时就删除几个非核心线程.

可以把核心线程想象为一个公司的正式员工,而非核心线程就是实习生,对于正式员工来说,是不能随便删除的(因为劳动法~),而实习生是可以随便开除的,当任务多时,就多招几个实习生来帮我干活,任务少了,就开除这些实习生(老铁扎心了吧)

核心线程保证了低负载情况下任务的正常运行,非核心线程可以有效应对高负载的情况

**long keepAliveTime, TimeUnit unit**

keepAliveTime:非核心线程在空闲状态下的存活时间

unit:时间单位

对于非核心线程来说,如果在一定时间内处于空闲状态,没有执行任务,系统就会讲这些空闲的非核心线程销毁,节省系统资源,keepAliveTime就是规定最多空闲时间是多少,TimeUnit unit是空闲时间的单位,TimeUnit 是一个枚举类型,里面存放时间的的单位(秒/分/时)

比如:keepAliveTime是5,unit为TimeUnit.SECONDS,这意味着非核心线程在空闲5s之后就会被销毁

**BlockingQueue<Runnable> workQueue**

workQueue:用于存放要执行任务的阻塞队列,等待线程池中的线程从阻塞队列中获取相应的任务并执行,此时用户端就是生产者,执行任务的线程池就是消费者.队列中的元素就是要执行的任务Runnable

不同的阻塞队列的使用场景也不同,主要考虑容量限制和阻塞策略,可以根据不同队列的性质进行选择

**ThreadFactory threadFactory**

threadFactory:通过工厂模式创建出来的定制化的线程

ThreadFactory 是一个接口,只有一个方法,用于创建自定义的线程

public interface ThreadFactory {
    Thread newThread(Runnable r);
}

也就是ThreadFactory threadFactory这个参数就是让我们为线程池提供自己创建的自定义的线程,以下是一个简单的使用例子

// 创建自定义的线程  先让其实现ThreadFactory接口
class MyCustomThread implements ThreadFactory {
    // 设置属性  自定义线程的前缀
    private final String threadNamePrefix = "MyCustomThread - ";
    // 自定义线程的编号
    private int threadCnt = 0;
    @Override
    public Thread newThread(Runnable r) {
        // 规定线程要执行的任务
        Thread t = new Thread(r);
        t.setName(threadNamePrefix + ++threadCnt);
        return t;
    }
}
public class Demo2 {
    public static void main(String[] args) {
        MyCustomThread myCustomThread = new MyCustomThread();
        // 利用自定义线程创建出线程池
        ExecutorService executorService = Executors.newFixedThreadPool(5,myCustomThread);
        // 提交任务
        for (int i = 0; i < 5; i++) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    // 打印当前正在执行任务的线程名称
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
    }
}

打印结果:

注意:因为在多线程编程中,线程的调度是随机的,所以每次打印的结果也是不同的

**RejectedExecutionHandler handler**

handler:线程池的拒绝策略对于一个线程池来说,其能容纳的线程数量是有限的,当超过最大的容量时,线程池会有一定的拒绝策略来阻止容量超过最大的限制,不同的拒绝策略有不同的效果,具体来说有以下四种拒绝策略:

直接抛出异常(我就是不让你超过限制,一超过限制就报错)这种策略是默认策略
丢弃当前新加的任务(添加进来新的任务就抛弃)
丢弃任务队列中最老的任务(老弱病残终究会被淘汰的)
添加的任务由添加任务的线程负责执行(这样做是为了尽量不丢失任务,添加任务的线程不是线程池中的线程,哪个线程往线程池中提交的任务就交给谁执行)

以上就是ThreadPoolExecutor类构造方法所有参数的讲解,其中corePoolSize和RejectedExecutionHandler是面试中最常考的!!!

4.线程池的模拟实现

如何去模拟实现一个线程池呢?需要先清楚了解线程池的基本组成,线程池由以下三部分组成

BlockingQueue:任务队列 用于存放线程池中线程要执行的任务
线程池:线程池的核心主体还是多个用于执行任务的线程
submit方法:用于提交任务,用于连接任务队列和线程池

代码实现:

class MyThreadPool {
    // 创建一个任务队列  用于存放线程池要执行的任务  10代表次任务队列最多存放的任务数量是10  超过10就要阻塞等待
    private BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(10);
    // 创建提交方法  将任务提交到任务队列之中
    public void submit(Runnable runnable) throws InterruptedException {
        // 此处采用的拒绝策略就是使用阻塞队列  队列满 阻塞等待
        queue.put(runnable);
    }
    // 创建构造方法
    public MyThreadPool(int n) {
        // 创建n个线程  就相当于newFixedPool的效果 创建出制定容量的线程池
        for (int i = 0; i < n; i++) {
            // 线程池中的线程是要执行任务的  获取任务队列中的任务 执行
            Thread t = new Thread(() -> {
                try {
                    Runnable runnable = queue.take();
                    runnable.run();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            });
            t.start();
        }
    }
}
public class Demo3 {
    public static void main(String[] args) throws InterruptedException {
        MyThreadPool myThreadPool = new MyThreadPool(10);
        for (int i = 0; i < 10; i++) {
            final int id = i;
            myThreadPool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程执行id" + id);
                }
            });
        }
    }
}

运行结果:

5.线程数量如何决定?

在使用线程池的时候,如何确定线程池内部的线程数量呢?在网上其实有很多种说法,假设cpu的逻辑核心数是N,线程的数目可以设置为N,N-1,N-2,2N,1.5N等等,其实这些说法都不准确,再你没有接触到实际的项目之前,线程的数目是不可能确定的

我们要执行的代码可以分为以下两类:

cpu密集型:代码中大量存在需要进行算术运算和逻辑判断
I/O密集型:代码涉及到I/O操作

假设一个代码中都是cpu密集型的代码(很吃cpu资源),cpu的逻辑核心数是N,那你设置的线程数目最多只能是N,一个线程的执行对应着一个cpu逻辑核心,如果创建的线程数目比逻辑核心N还多,就没有cpu来执行多出的线程了,反而造成了资源的浪费

假设一个代码中全是I/O密集型的代码,此时线程池中的线程数目是可以大于N的,因为一个cpu上可以调度执行这些操作~I/O操作不吃cpu

对于我们所写的代码来说,我们不知道有多少cpu密集型的,有多少I/O密集型的,也就无法直接确定设置的线程数目,正确方法应该是通过性能测试来确定线程的数量,即不断地更换线程数,看什么情况下能达到性能的最优化,通过测试找出应设置的线程数

补充:I/O操作是指计算机系统与外部链接设备之间的数据传输,常见的I/O操作包括文件读取,数据库连接,网络通信等等

6.线程池构造方法的进一步认识

1.newFixedThreadPool

源码:

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

讲解

2.newCachedThreadPool

源码:

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

讲解:

3.newSingleThreadExecutor

源码:

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

讲解:

4.ScheduledThreadPoolExecutor

源码:

public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

讲解:

最后附上多线程设计模式的思维导图

创作不易!!!欢迎大家多多转发支持!

多线程编程设计模式(单例,阻塞队列,定时器,线程池)（四）