首页 > 编程语言 >JAVAEE之线程（10）_线程池、线程池的创建、实现线程池

JAVAEE之线程（10）_线程池、线程池的创建、实现线程池

时间：2024-05-25 19:03:53浏览次数：19  
标签：10 int 创建 JAVAEE 线程 new public ThreadPoolExecutor

一 线程池

1.1为什么要有线程池？

 线程池顾名思义是由多个线程所组成，作用就是减少线程的建立与销毁，与数据库连接池相同概念，为了减少连接与释放，从而降低消耗提升效率。

1.2 线程池的优势

总体来说，线程池有如下的优势：

  1. 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

  2. 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。

  3. 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

1.3 线程池的创建

 在JAVA的标准库中，通过Executor框架的工具类Executors来创建线程池。Executors 创建线程池的几种方式：

  1. newFixedThreadPool: 创建固定线程数的线程池；
  2. newCachedThreadPool: 创建线程数目动态增长的线程池；
  3. newSingleThreadExecutor: 创建只包含单个线程的线程池；
  4. newScheduledThreadPool: 设定 延迟时间后执行命令，或者定期执行命令。
package PoolThread;

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

/**
 * @author Zhang
 * @date 2024/5/1119:48
 * @Description:
 */
public class Test {

    public static void main(String[] args) {
        ExecutorService service  = Executors.newCachedThreadPool();   //此时构造出的线程池对象，有一个基本的特点：线程数目是能够自适应的
        ExecutorService service1 = Executors.newFixedThreadPool(4);  //创造线程的数目是固定的
        ExecutorService service2 = Executors.newSingleThreadExecutor();   //只有一个线程的线程池
        ExecutorService service3 = Executors.newScheduledThreadPool(500);   //设定 延迟时间后执行命令，或者定期执行命令
        
        service1.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello World");
            }
        });
    }
}

注意：Executors 本质上是 ThreadPoolExecutor 类的封装。ThreadPoolExecutor 提供了更多的可选参数, 可以进一步细化线程池行为的设定，我们将后续介绍
在这里插入图片描述

二、 通过ThreadPoolExecutor创建线程池

2.1 其构造方法有如下4种

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
}

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         threadFactory, defaultHandler);
}

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          RejectedExecutionHandler handler) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), handler);
}
-----------------------------------------------------

我们主要看第四个方法，因为其他几个构造方法都是调用这个。

//4. 
    /**
     * 用给定的初始参数创建一个新的ThreadPoolExecutor。
     */
    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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

ThreadPoolExecutor中的参数说明：

  1. corePoolSize：核心线程数maximumPoolSize：最大线程数，任务队列存放的任务达到队列容量的时候，同时运行的最大线程数量。
  2. workQueue：新的任务进来的时候，先判断当前运行的线程数是否大于或者核心线程数，如果达到，则会被放入队列中。
  3. keepAliveTime：线程池中的线程数量>核心线程数，如果这时未有新任务提交，非核心线程不会立即销毁，而是会等待，直到等待时间超过了keepAliveTime才会被回收。
  4. unit：keepAliveTime 参数的时间单位。
  5. threadFactory：线程工厂 用来创建线程，一般默认即可。
  6. handler：拒绝策略，如果当前的线程数已经达到最大线程数，并且队列中也被放满了任务，则需要执行拒绝策略。
    ThreadPoolExecutor.AbortPlicy：抛出异常，默认策略。ThreadPoolExecutor.DiscardPolicy：直接丢弃任务，但不抛出异常。
    ThreadPoolExecutor.DsicardOldestPolicy：丢弃最早的任务，将新任务加入队列。
    ThreadPoolExecutor.CallerRunsPolicy：由线程池所在的的线程处理任务，自己处理自己的。

2.2 使用ThreadPoolExecutor正确创建线程池

static ThreadFactory factory = new ThreadFactoryBuilder().setNameFormat("创建线程").build();

  static ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 20, 60, TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(30), factory, new ThreadPoolExecutor.AbortPolicy());

    public static class MyThread implements Runnable {
        @Override
        public void run() {
            System.out.println("创建线程成功");
        }
    }
    public static void main(String[] args){
        MyThread myThread = new MyThread();
        executor.submit(myThread);
    }

其中，调用线程执行有两个方法，submit和execute：

  1. submit的作用是可以通过return获取返回值；
  2. execute是无返回值的。

三、自己实现一个线程

实现过程：

  1. 核心操作为 submit， 将任务加入线程池中；
  2. 使用 Worker 类描述一个工作线，使用 Runnable 描述一个任务；
  3. 使用一个 BlockingQueue 组织所有的任务；
  4. 每个 worker 线程要做的事情: 不停的从 BlockingQueue 中取任务并执行；
  5. 指定一下线程池中的最大线程数 maxWorkerCount; 当当前线程数超过这个最大值时, 就不再新增线程了。

相关实例实现代码：

package PoolThread;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingDeque;

/**
 * @author Zhang
 * @date 2024/5/1120:28
 * @Description:
 */


class  MyThreadPool{
    //任务队列
    private ArrayBlockingQueue<Runnable> queue = new ArrayBlockingQueue<Runnable>(1000);

    //通过这个方法，把任务添加到队列中
    public void submit(Runnable runnable) throws InterruptedException {

        //阻塞等待
        queue.put(runnable);
    }


    public  MyThreadPool(int n){
        //创建n个线程，负责执行上述队列的任务
        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 Test2 {

    public static void main(String[] args) throws InterruptedException {

        MyThreadPool myThreadPool = new MyThreadPool(4);
        for (int i = 0; i < 1000; i++) {
            int id = i;
            myThreadPool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("执行任务"+ id);
                }
            });
        }

    }
}

标签：10,int,创建,JAVAEE,线程,new,public,ThreadPoolExecutor
From： https://blog.csdn.net/2301_80653026/article/details/139200945

相关文章

  • STM32F103C8T6独立看门狗学习笔记
    /*------------操作说明-------------------键寄存器IWDG_PR寄存器地址0x40003000初始值0X000000000X00005555解除对IWDG_PR、IWDG_RLR和IWDG_WINR寄存器的写入访问保护0X0000CCCC启动独立看门狗0X0000AAAA喂狗......
  • 进程和线程的区别
    进程与线程的区别进程：进程是操作系统中资源分配的基本单位。它包括程序代码、打开的文件、挂起的信号、内核内部数据、处理器状态、内存地址空间等。进程拥有独立的地址空间，这意味着每个进程都有自己的内存空间，一个进程不能直接访问另一个进程的内存空间，除非通过进程间通信（IPC......
  • 代码随想录算法训练营第十六天 | 104.二叉树的最大深度、559.n叉树的最大深度、111.二
    104.二叉树的最大深度题目链接：https://leetcode.cn/problems/maximum-depth-of-binary-tree/文档讲解：https://programmercarl.com/0104.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%9C%80%E5%A4%A7%E6%B7%B1%E5%BA%A6.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE......
  • P10380 「ALFR Round 1」D 小山的元力
    历时两天，算是搞出来了。P10380「ALFRRound1」D小山的元力-洛谷|计算机科学教育新生态(luogu.com.cn)提醒首先如果你是用Lucas定理并用阶乘形式来求组合数的，请判断组合数是否成立，即\(C_a^b\)，\(a\)是否大于等于\(b\)。如果小于你将re几个点，如果是直接用快速幂求......
  • 企业生产环境中的麒麟V10（ARM架构）操作系统部署jdk和redis三主三从交叉版集群
    前言：麒麟ARM操作系统是国企和政务机关推行信创化选择率比较高的一款操作系统，然而ARM操作系统非主流的X86系统，除了命令一样，在架构方面差别极大，初次接触多多少少会踩坑，下面我将在公司中部署的实例列举出来，供大家参考，ip和设计机密信息不方便展示，统用虚拟信息代替。经过多次验证，用了......
  • 【NOI2010】能量采集 题解
    【NOI2010】能量采集题解谨纪念我的第一道手推出来的莫反题。题目大意：已知\(n\)，\(m\)，求\(\sum\limits_{i=1}^n\sum\limits_{j=1}^m(2\cdot\gcd(i,j)-1)\)。首先变形一手：\[\sum\limits_{i=1}^n\sum\limits_{j=1}^m(2\cdot\gcd(i,j)-1)=2\sum\limits_{i=1}^n\sum\limits_{j=......
  • Java 多线程编程 力扣实题
    多线程编程实例了解内存模型、线程通信和线程安全之后，对多线程编程已经有了理论上的认知，现在来实战一下。所有题目在https://leetcode.cn/problemset/concurrency/。按序打印题干描述给你一个类：publicclassFoo{publicvoidfirst(){print("first");}publicvoidseco......
  • Java 多线程编程基础
    我们的应用程序都是运行在多线程的环境下的，在多线程环境下的许多问题我们都了解吗？线程间如何进行数据交换？线程间如何进行通信与协作？共享一个资源时如何保证线程安全？线程数据交换线程之间无法直接访问对方工作内存中的变量，必须通过主内存进行变量的传递。例如，线程A、B共享一......
  • AP5126 降压恒流IC 5-100V 1A LED汽车灯驱动芯片
    产品描述AP5126是一款PWM工作模式,高效率、外围简单、内置功率管，适用于输入的高精度降压LED恒流驱动芯片。输出最大功率可达15W，最大电流1.5A。AP5126可实现全亮/半亮功能切换，通过MODE切换：全亮/半亮/循环模式。AP5126工作频率固定在140KHZ，同时内置抖频电路，可......
  • AP5170 降压恒流IC 4.5-100V 1.5A LED汽车灯驱动IC
    产品描述AP5170是一款效率高，稳定可靠的LED灯恒流驱动控制芯片，内置高精度比较器，固定关断时间控制电路，恒流驱动电路等，特别适合大功率LED恒流驱动。AP5170采用ESOP8封装，散热片内置接SW脚，通过调节外置电流检测的电阻值来设置流过LED灯的电流，支持外加电压线性调光，最大......

赞助商

阅读排行

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

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

Copyright © 2020-2023 IPS99 版权所有 IPS99