首页 > 编程语言 >【JavaEE精炼宝库】多线程（6）线程池

【JavaEE精炼宝库】多线程（6）线程池

时间：2024-06-16 20:28:58浏览次数：26  
标签：创建 JavaEE 工厂 线程 3.1 new 多线程 public

目录

一、线程池的概念及优势

1.1 线程池的概念：

1.2 线程池的优势：

二、工厂模式

三、标准库中的线程池

3.1 标准库线程池参数解释：

3.1.1 corePoolSize | maximumPoolSize：

3.1.2 keepAliveTime | unit：

3.1.3 workQueue： 

3.1.4 ThreadFactory： 

3.1.5 handler：

3.2 创建线程池演示：

3.3 利用线程池的工厂类来创建线程池：

3.4 线程池的使用演示：

四、线程池的实现

一、线程池的概念及优势

1.1 线程池的概念：

线程池是一种并发编程的技术，它维护着一组预先创建的线程，以便在需要时重用它们来执行多个任务。这可以提高程序的性能和效率，因为线程的创建和销毁通常是昂贵的操作，通过重用线程，可以减少这种开销。

在我们前面已经介绍了线程比进程更加轻量，在频繁创建销毁的时候，线程更有优势。但是随着时代的发展，对于 “频繁” 有了新的定义（比如之前 1 万就认为是频繁，但是现在可能 1000 万才认为是频繁）。即使是线程，在如此频繁的创建和销毁的情况下，开销也变得难以接受。

那么要怎么优化呢？

答：我们可以通过线程池和协程进行优化。

协程这里我们暂且不进行描述，Go 语言主打的卖点就是使用协程处理并发编程。线程池的优化我们马上讲到。

1.2 线程池的优势：

• 降低资源消耗：

减少线程的创建和销毁带来的性能开销。

• 提高响应速度：

当任务来时可以直接使用，不用等待线程创建

• 可管理性：

进行统一的分配，监控，避免大量的线程间因互相抢占系统资源导致的阻塞现象。

二、工厂模式

在下面即将介绍的线程池参数中，其中有一个参数是工厂类。所以在这里提前给大家解释一下什么是工厂模式。

工厂模式：也是一种设计模式，主要解决的问题是构造方法创建对象太坑了的问题。为什么说构造方法创建对象有坑呢？举个栗子：

因为在 Java 的语法中要求构造方法的命名必须是类名且参数类型和个数，排列顺序不能一样。这就导致遇到上面这种案例解决不了。就需要工厂模式，核心思路，不使用构造方法创建对象，给构造方法包装一层。例如下面这段代码：这只是个伪代码，看看思路就行，makePointByXY 这样的方法就叫 “工厂方法”，这样写代码的套路就叫做 “工厂模式”，没有什么特别的。

public class Point {
    public static Point makePointByXY(double x,double y){
        Point p = new Point();
        p.setX(x);//和 setR 是有区别的，比如传给的函数不一样
        p.setY(y);
        return p;
    }
    public static Point makePointByRA(double r,double a){
        Point p = new Point();
        p.setR(r);
        p.setA(a);
        return p;
    }
}

工厂类的写法如下图： 工厂方法用单独的类来进行提供。

如果语法层面上，不强制要求构造方法名字必须和类名一致，就没有上述模式的必要了。

三、标准库中的线程池

3.1 标准库线程池参数解释：

ThreadPoolExecutor：

使用起来比较复杂，在其构造方法中，包含很多的参数。（面试考点）例如下面这个就是包含全部参数的构造方法，了解这个了，其他的就都会了，下面会围绕这个构造方法参数进行解释。

3.1.1 corePoolSize | maximumPoolSize：

在 Java 的标准库中线程池把线程分成两类：1. 核心线程。2. 非核心线程。

顾名思义 corePoolSize 就是核心线程数，maximumPoolSize 就是最大线程数（核心线程数 + 非核心线程数）。

这里就涉及到动态扩展的概念，在线程池刚开始就会创建出核心线程数的线程（最小线程数），随着项目的进行，如果添加的任务比较多的话，核心线程数处理不过来了（有很多任务在队列中，排队等待执行），这个时候线程池就会自动的创建出新的线程，来支撑更多的任务。但是，创建出来的线程总数不能超过最大线程数（maximumPoolSize），过了一段时间，任务没有那么多了，线程 “清闲下来” 这时部分非核心线程就会被释放掉，线程池中会保证线程数目不少于核心线程数。

这样就既可以保证任务多的时候的效率，也能保证任务少的时候，系统的开销。到这里就又有了一个问题：

在实际开发中，线程数应该设置成多少合适呢？

答：只要是具体的数字，答案一定是错误的。我们要根据实验的方式，对程序进行性能测试，测试过程中，设定不同的线程池的数值。最终根据实际程序的响应速度和系统开销，综合权衡，找到一个合适值。

这不仅仅和电脑的配置有关（有多个 CPU 核心），更重要的是，和我们的程序的实际特点有关系。极端情况下可以分为两大类：

• CPU 密集型程序：代码完成的逻辑，都是要通过 CPU 来完成的.（此时的性能瓶颈是 CPU）。此时线程的数量是不应该超过 CPU 逻辑核心数的。

• IO 密集型程序：代码大部分时间在等待 IO（等待 IO 是不消耗 CPU，不参与调度）。此时瓶颈就不在 CPU 上，我们更多考虑其他方面（比如网络程序，要考虑网卡宽带的瓶颈）。

3.1.2 keepAliveTime | unit：

• keepAliveTime：

表示非核心线程，允许空闲的最大时间。也就是说非核心线程在线程池 ”不忙“ 的时候不是马上回收掉。

• unit：

TimeUnit：这是一个枚举类型。其中的枚举常量有：

3.1.3 workQueue： 

阻塞队列我们上一篇文章已经自己实现过了，这里利用阻塞队列要存储 Runnable 对象也就是要执行的任务。线程池会提供 submit 方法，让其他线程把任务提交给线程池。其他线程会 submit 任务到这个队列中，这个队列存的元素就是 Runnable 对象，要执行的逻辑就是 run 方法里面的内容。

3.1.4 ThreadFactory： 

ThreadFactory：是标准库中提供的，用来创建线程的工厂类。这个线程工厂，主要是为了批量的给创建的线程设置一些属性， 线程工厂在它的工厂方法中，把线程的属性提前初始化好了。至于什么是工厂类，在上面的工厂模式那里已经解释过了，这里就不再赘述。

3.1.5 handler：

面试官问线程池的参数都是什么意思？其实就是在考我们对于这个参数的理解，前面 6 个都是添头。注意：此处 Handler 不是句柄的意思（句柄的术语也是 Handler）。

这里可以理解为拒绝策略，如果当前任务队列满了，仍要继续添加任务，咋办呢？直接阻塞其实不太合适。所以这里多了一个拒绝策略的参数。

幸运的是，我们 Java 的大佬已经给我们实现了四种常用的拒绝策略，在 ThreadPoolExecutor 类的里面，有四种静态内部类，列举如下：

对上面四种拒接策略的简单翻译如下：

 • AbortPolicy()：超过负荷，直接抛出异常。

 • CallerRunsPolicy()：调用者负责处理多出来的任务。

 • DiscardOldestPolicy()：丢弃队列中最老的任务。

 • DiscardPolicy()：丢弃新来的任务。

3.2 创建线程池演示：

这里唯一有些难度的就是拒绝策略的创建，在 ThreadPoolExecutor 类中有四个内部类实现了 RejectedExecutionHandler 接口。具体代码如下：

简单的编写如下： 

import java.util.concurrent.*;
public class demo3 {
    public static void main(String[] args) {
        BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(5);//阻塞队列
        ThreadFactory factory = new ThreadFactory() {//工厂模式
            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r);//这里就可以对 Thread 设置一些参数
            }
        };
        RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();//拒绝策略，注意这里是调用 ThreadPoolExecutor 的静态内部类
        ThreadPoolExecutor pool = new ThreadPoolExecutor(3,6,100,TimeUnit.DAYS,
                queue,factory,handler);
    }
}

3.3 利用线程池的工厂类来创建线程池：

使用线程池的工厂类来创建线程池的方法一共有 6 种，其中我们重点理解下面给出的四种即可。

工厂类为：Executors ，这里产生的线程池为 ExecutorService 类。具体如下图：

可以看到官方提供的创建线程池的工厂方法还是很多的。我们主要理解下面这四个即可。

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
public class demo1 {
    public static void main(String[] args) {
        //能够根据任务数量，自动进行线程扩容的线程池
        ExecutorService sevice1 = Executors.newCachedThreadPool();
        //创建固定线程数目的线程池
        ExecutorService service2 = Executors.newFixedThreadPool(4);
        //创建只包含单个线程的线程池
        ExecutorService service3 = Executors.newSingleThreadExecutor();
        //创建固定数目的线程个数，但是任务延时执行的线程池
        ExecutorService service4 = Executors.newScheduledThreadPool(4);
    }
}

Executors 创建线程池的几种方式：

• newFixedThreadPool：创建固定线程数的线程池。

• newCachedThreadPool：创建线程数目动态增长的线程池。

• newSingleThreadExecutor：创建只包含单个线程的线程池。

• newScheduledThreadPool：设定延迟时间后执行命令，或者定期执行命令。

Executors 本质上是 ThreadPoolExecutor 类的封装。 

3.4 线程池的使用演示：

 我们可以利用 submit 来进行添加任务（每个都必须实现 Runnable 接口）。

import java.util.concurrent.*;
public class demo1 {
    public static void main(String[] args) {
        ExecutorService service1 = Executors.newCachedThreadPool();
        for(int i = 1;i <= 1000;i++){
            int id = i;//这里必须要使用 id 来接受 i
            service1.submit(new Runnable() {//匿名内部类
                @Override
                public void run() {
                    System.out.println(id +" , " + Thread.currentThread().getName());//必须只能打印 id，打印 i 会报错
                    //报错的原因为：变量捕捉
                }
            });
        }

    }
}

案例演示的结果如下：

至于剩下三个线程池都是一样的，这里就不过多赘述了。 如果只是简单的使用一下，就直接用工厂类即可，如果希望更加精细的控制，就使用原生的 ThreadPoolExecutor。所以 Java 标准库线程池的创建方式一共有 7 种。

四、线程池的实现

为了更加深入的理解线程池的使用，这里我们就来简单的实现一个简易的线程池。我们要实现的东西有1. 若干线程。2. 任务队列。3. 提供 submit 方法。

我们可以利用 ArrayList 来存储线程，利用阻塞队列来辅助完成线程池，创建一个能自动扩容的线程池，每个线程的任务就是不停的去阻塞队列中取元素然后执行。剩下的一些在代码中都有注释。

代码实现如下：

import java.util.concurrent.*;
import java.util.*;
//自己实现一个线程池
class MyThreadPool{
    //1. 线程
    private int corePoolSize;//核心线程数
    private int maximumPoolSize;//最大线程数
    private BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>(1000);

    private List<Thread> threads = new ArrayList<>();//存储线程
    public MyThreadPool(int coreThreadSize,int maximumPoolSize) throws InterruptedException {
        this.corePoolSize = coreThreadSize;
        this.maximumPoolSize = maximumPoolSize;
        for(int i = 0;i < coreThreadSize;i++){
            Thread t = newThread();
            t.start();
            threads.add(t);
        }
    }
    private Thread newThread(){
        //每个线程的任务就是不停的执行队列中的元素
        Thread t = new Thread(() -> {
            while(true){
                try {
                    Runnable task = queue.take();
                    task.run();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        return t;
    }
    //2. 阻塞队列
    //3. submit 方法
    public void submit(Runnable task) throws InterruptedException {
        queue.put(task);
        //如果队列中的元素大于一个阈值，且线程数小于最大线程数时，就可以创建新的线程来帮助，处理队列中的元素
        if(queue.size() >= 50 && threads.size() < maximumPoolSize){
            //创建 线程
            Thread t = newThread();
            t.start();
            threads.add(t);
        }
    }
}
public class demo3 {
    public static void main(String[] args) throws InterruptedException {
        MyThreadPool threadPool = new MyThreadPool(4,50);
        for(int i = 0;i < 10000;i++) {
            int id = i;
            threadPool.submit(new Runnable(){
                @Override
                public void run(){
                    System.out.println("hello " + id + " ," + Thread.currentThread().getName());
                }
            });
        }
    }
}

具体效果如下：

如果要实现拒绝策略的话，也是在 submit 这里实现。 

结语：

其实写博客不仅仅是为了教大家，同时这也有利于我巩固知识点，和做一个学习的总结，由于作者水平有限，对文章有任何问题还请指出，非常感谢。如果大家有所收获的话还请不要吝啬你们的点赞收藏和关注，这可以激励我写出更加优秀的文章。

标签：创建,JavaEE,工厂,线程,3.1,new,多线程,public
From： https://blog.csdn.net/2301_80035594/article/details/139635058

相关文章

  • [转]32th@深入解析C++并发编程：从多线程到现代C++并发库@20240616
    深入解析C++并发编程：从多线程到现代C++并发库你有没有想过，为什么C++在多线程并发编程方面如此强大？C++11标准的发布，为并发编程带来了哪些革命性的变化？本文将深入探讨C++并发编程背后的技术原理，带你领略现代C++并发库的强大之处。文章将结合代码片段，为你揭示C++并发编程的精髓。1.......
  • JAVA多线程实现的三种方式
    1.继承Thread类classExtendThreadextendsThread{//继承自ThreadprivateStringname;publicExtendThread(Stringname){this.name=name;}@Overridepublicvoidrun(){//必须重写run方法，并......
  • （pdf）图解java多线程设计模式.pdf (结城浩)
    书：pan.baidu.com/s/1tGbGhhQ3Ez1SIkqdEREsjQ?pwd=eqp0提取码：eqp0线程基础知识：介绍线程的概念、生命周期、状态转换等基本内容，为后续的多线程设计打下基础。Java线程API：详细讲解Java中线程的创建、启动、控制以及线程间的协作机制，如Thread类、Runnable接口等。线程同步与互斥：......
  • 多线程面试基础篇（面试必备，值得收藏）
    1.并发与并行并行：指两个或多个事件在同一时刻发生（同时执行）。并发：指两个或多个事件在同一个时间段内发生(交替执行)。并发指的是在一段时间内宏观上有多个程序同时运行，微观上这些程序是分时的交替运行在多个CPU系统中，则这些可以并发执行的程序便可以分配到多个处理器上（CPU），......
  • springboot的多线程事务能否保证事务的一致性
    在SpringBoot中，多线程事务的一致性取决于事务管理的配置和实现。SpringFramework本身提供了多种事务管理的方式，如基于注解的声明式事务、编程式事务等。在多线程环境下，要保证事务的一致性需要特别注意以下几点：事务传播属性（TransactionPropagation）：在进行多线程事务处理时，需......
  • IO、进程、线程面试题
    1.标准IO和文件IO的区别1.标准IO标准IO是基于缓存的IO，也就是说，在进行IO操作时，数据会先被读入缓存，然后再进行实际的IO操作。标准IO的优点是对于大文件的读写操作效率比较高，因为可以利用缓存来避免频繁的系统调用。此外，标准IO还提供了一系列方便的API函数，例如printf、scanf等......
  • 11.NiO多线程优化
    场景单线程配合一个selector选择器管理多个channel上的事件。问题1.多核cpu,如果是单线程就会让cpu的力量被浪费。2.单线程处理多个事件，如果某个事件耗费时间比较久，就会影响其它事件的处理。例如：redis单线程写的，底层网络用的类似于nio和selector方式编写，所以缺点就是某个......
  • 线程池
    使用线程池带来的三个好处第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。假设一个服务器完成一项任务所需时间为：T1创建线程时间，T2在线程中执行任务的时间，T3销毁线程时间......
  • 认识 Java 里的线程和方法
    Thread和Runnable的区别Thread才是Java里对线程的唯一抽象，Runnable只是对任务（业务逻辑）的抽象。Thread可以接受任意一个Runnable的实例并执行启动线程的方式有：1、XextendsThread;，然后X.start2、XimplementsRunnable；然后交给Thread运行永远都只有thread.star......
  • 什么是进程和线程
    什么是进程和线程进程是系统运行资源分配的最小单位进程是操作系统进行资源分配的最小单位,其中资源包括:CPU、内存空间、磁盘IO等,同一进程中的多条线程共享该进程中的全部系统资源,而进程和进程之间是相互独立的。进程是具有一定独立功能的程序关于某个数据集合上的一次运行......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99