Java——全局线程池

最新推荐文章于 2024-04-30 17:28:01 发布
最新推荐文章于 2024-04-30 17:28:01 发布
阅读量2.5k 收藏 13
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39544175/article/details/126818665
版权

Java——全局线程池

1. 为什么要全局线程池

通常在项目中使用线程池时，不会直接在方法中或类中直接创建，这样太浪费内存了。普遍的做法是定义个全局线程池，然后提供给项目需要的地方使用。

2. 带有生命周期管理的全局线程池实现

全局线程池所需的功能：

  1. 线程池单例，如果不是单例那就跟在任何地方创建线程池没区别了，所以一定要保持单例；
  2. 线程池通用方法，比如提交任务，延迟执行任务，定时执行任务等。

一般从这两方面实现，但这里加多个功能就是线程池生命周期的管理，就是当应用正常关闭时，线程池需要优雅地关闭，将执行完其中的任务。

在这里插入图片描述

首先看线程池工厂类，这里分了普通的线程池和带有生命周期的线程池，线程池类型分别有单线程、固定线程、定时任务线程池。

ExecutorFactory

/**
 * 线程池工厂
 * @author Tarzan写bug
 * @since 2022/09/08
 */
public class ExecutorFactory {

    /**
     * 单线程线程池
     * @return
     */
    public static ExecutorService newSingleExecutorService() {
        return Executors.newFixedThreadPool(1);
    }

    /**
     * 单线程线程池
     * @param threadFactory 线程工厂
     * @return
     */
    public static ExecutorService newSingleExecutorService(ThreadFactory threadFactory) {
        return Executors.newFixedThreadPool(1, threadFactory);
    }

    /**
     * 固定线程先线程池
     * @param threadNum 线程数量
     * @return
     */
    public static ExecutorService newFixedExecutorService(int threadNum) {
        return Executors.newFixedThreadPool(threadNum);
    }

    /**
     * 固定线程线程池
     * @param threadNum 线程数量
     * @param threadFactory 线程工厂
     * @return
     */
    public static ExecutorService newFixedExecutorService(int threadNum, ThreadFactory threadFactory) {
        return Executors.newFixedThreadPool(threadNum, threadFactory);
    }

    /**
     * 单线程定时任务线程池
     * @return
     */
    public static ExecutorService newSingleScheduleExecutorService() {
        return Executors.newScheduledThreadPool(1);
    }

    /**
     * 单线程定时任务线程池
     * @param threadFactory 线程工厂
     * @return
     */
    public static ExecutorService newSingleScheduleExecutorService(ThreadFactory threadFactory) {
        return Executors.newScheduledThreadPool(1, threadFactory);
    }

    /**
     * 固定线程定时任务线程池
     * @param threadNum 线程数量
     * @return
     */
    public static ExecutorService newScheduleExecutorService(int threadNum) {
        return Executors.newScheduledThreadPool(threadNum);
    }

    /**
     * 固定线程定时任务线程池
     * @param threadNum 线程数量
     * @param threadFactory 线程工厂
     * @return
     */
    public static ExecutorService newScheduleExecutorService(int threadNum, ThreadFactory threadFactory) {
        return Executors.newScheduledThreadPool(threadNum, threadFactory);
    }

    /**
     * 带有生命周期的线程池
     */
    public static class Managed {

        /**
         * 单线程线程池
         * @return
         */
        public static ExecutorService newSingleExecutorService() {
            ExecutorService executorService = Executors.newFixedThreadPool(1);
            ThreadPoolManager.register(executorService);
            return executorService;
        }

        /**
         * 单线程线程池
         * @param threadFactory 线程工厂
         * @return
         */
        public static ExecutorService newSingleExecutorService(ThreadFactory threadFactory) {
            ExecutorService executorService = Executors.newFixedThreadPool(1, threadFactory);
            ThreadPoolManager.register(executorService);
            return executorService;
        }

        /**
         * 固定线程线程池
         * @param threadNum 线程数量
         * @return
         */
        public static ExecutorService newFixedExecutorService(int threadNum) {
            ExecutorService executorService = Executors.newFixedThreadPool(threadNum);
            ThreadPoolManager.register(executorService);
            return executorService;
        }

        /**
         * 固定线程线程池
         * @param threadNum 线程数量
         * @param threadFactory 线程工厂
         * @return
         */
        public static ExecutorService newFixedExecutorService(int threadNum, ThreadFactory threadFactory) {
            ExecutorService executorService = Executors.newFixedThreadPool(threadNum, threadFactory);
            ThreadPoolManager.register(executorService);
            return executorService;
        }

        /**
         * 单线程定时任务线程池
         * @return
         */
        public static ExecutorService newSingleScheduleExecutorService() {
            ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);
            ThreadPoolManager.register(executorService);
            return executorService;
        }

        /**
         * 单线程定时任务线程池
         * @param threadFactory 线程工厂
         * @return
         */
        public static ExecutorService newSingleScheduleExecutorService(ThreadFactory threadFactory) {
            ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1, threadFactory);
            ThreadPoolManager.register(executorService);
            return executorService;
        }

        /**
         * 固定线程线程池
         * @param threadNum 线程数量
         * @return
         */
        public static ScheduledExecutorService newScheduleExecutorService(int threadNum) {
            ScheduledExecutorService executorService = Executors.newScheduledThreadPool(threadNum);
            ThreadPoolManager.register(executorService);
            return executorService;
        }

        /**
         * 固定线程线程池
         * @param threadNum 线程数量
         * @param threadFactory 线程工厂
         * @return
         */
        public static ScheduledExecutorService newScheduleExecutorService(int threadNum, ThreadFactory threadFactory) {
            ScheduledExecutorService executorService = Executors.newScheduledThreadPool(threadNum, threadFactory);
            ThreadPoolManager.register(executorService);
            return executorService;
        }
    }
}

生命周期管理的线程池会注册到ThreadPoolManager中，该类初始化时会向Runtime.getRuntime()中添加应用关闭回调线程，而这个回调线程执行优雅关闭线程池集合。

ThreadPoolManager

/**
 * 线程池生命周期管理
 * @author Tarzan写bug
 * @since 2022/09/08
 */
public class ThreadPoolManager {

    private static final Logger LOGGER = LoggerFactory.getLogger(ThreadPoolManager.class);

    /**
     * 线程池集合
     */
    private static Set<ExecutorService> managedExecutors = new HashSet<>();

    /**
     * 对象锁，防并发写
     */
    private static final Object LOCK = new Object();

    /**
     * CAS
     */
    private static final AtomicBoolean CLOSED = new AtomicBoolean(false);

    /**
     * 单例
     */
    private static final ThreadPoolManager INSTANCE = new ThreadPoolManager();

    private ThreadPoolManager() {}

    static {
        // 应用关闭时，优雅关闭线程池
        ThreadUtil.addShutdownHook(new Runnable() {
            @Override
            public void run() {
                LOGGER.warn("start shutdown thread pool");
                shutdown();
                LOGGER.warn("shutdown thread pool finish");
            }
        });
    }

    /**
     * 单例
     * @return
     */
    public static ThreadPoolManager getInstance() {
        return INSTANCE;
    }

    /**
     * 注册线程池
     * @param executorService
     */
    public static void register(ExecutorService executorService) {
        synchronized (LOCK) {
            managedExecutors.add(executorService);
        }
    }

    /**
     * 注销线程池
     * @param executorService
     */
    public static void deregister(ExecutorService executorService) {
        synchronized (LOCK) {
            managedExecutors.remove(executorService);
        }
    }

    /**
     * 关闭线程池
     */
    private static void shutdown() {
        // CAS防止多次调用
        if (!CLOSED.compareAndSet(false, true)) {
            return;
        }
        for (ExecutorService managedExecutor : managedExecutors) {
            ThreadUtil.shutdownThreadPool(managedExecutor);
        }
    }
}

ThreadUtil提供应用关闭线程回调，和优雅关闭线程池方法

/**
 * 线程工具类
 * @author Tarzan写bug
 * @since 2022/09/08
 */
public class ThreadUtil {

    private static final Logger LOGGER = LoggerFactory.getLogger(ThreadUtil.class);

    private ThreadUtil() {}

    /**
     * 程序关闭时添加回调线程
     * @param runnable
     */
    public static void addShutdownHook(Runnable runnable) {
        Runtime.getRuntime().addShutdownHook(new Thread(runnable));
    }

    /**
     * 关闭线程池
     * @param executorService 线程池
     */
    public static void shutdownThreadPool(ExecutorService executorService) {
        executorService.shutdown();
        int retry = 3;
        if (retry > 0) {
            retry--;
            try {
                if (executorService.awaitTermination(1, TimeUnit.SECONDS)) {
                    return;
                }
            } catch (InterruptedException e) {
                executorService.shutdownNow();
                Thread.interrupted();
            } catch (Throwable ex) {
                LOGGER.error("shutdown thread pool has error: {}", ex);
            }
        }
        executorService.shutdownNow();
    }
}

接着就是提供给项目开发人员直接调用的全局线程池GlobalExecutor

/**
 * 全局线程池
 * @author Tarzan写bug
 * @since 2022/09/08
 */
public class GlobalExecutor {

    /**
     * 普通线程池
     */
    private static final ExecutorService COMMON_EXECUTOR = ExecutorFactory.Managed
            .newFixedExecutorService(Runtime.getRuntime().availableProcessors(),
                    new NameThreadFactory("com.mountain.threadpool.common"));

    /**
     * 定时线程池
     */
    private static final ScheduledExecutorService COMMON_SCHEDULE_EXECUTOR = ExecutorFactory.Managed
            .newScheduleExecutorService(Runtime.getRuntime().availableProcessors(),
                    new NameThreadFactory("com.mountain.threadpool.commmon.schedule"));

    private GlobalExecutor() {}

    /**
     * 提交任务到线程池中执行
     * @param runnable 线程任务
     */
    public static void submitCommonExecutor(Runnable runnable) {
        COMMON_EXECUTOR.submit(runnable);
    }

    /**
     * 提交任务到线程池中延迟执行
     * @param runnable 线程任务
     * @param delay 延迟时间
     * @param unit 时间单位
     */
    public static void scheduleCommonExecutor(Runnable runnable, long delay, TimeUnit unit) {
        COMMON_SCHEDULE_EXECUTOR.schedule(runnable, delay, unit);
    }

    /**
     * 提交任务到线程池中定时执行
     * @param runnable 线程任务
     * @param delay 延迟时间
     * @param fixed 定时时间
     * @param unit 时间单位
     */
    public static void scheduleWithFixedDelay(Runnable runnable, long delay, long fixed, TimeUnit unit) {
        COMMON_SCHEDULE_EXECUTOR.scheduleWithFixedDelay(runnable, delay, fixed, unit);
    }
}

3. 总结

全局线程池还要注意线程池中最大线程数量和阻塞队列的实现。由于最近在研究Nacos，所以上述实现借鉴了Nacos的源码。全局线程池还有很多实现方式，欢迎讨论和学习。上述代码收录在https://gitee.com/ouwenrts/tuyere.git.



谢谢阅读，就分享到这，未完待续…

欢迎同频共振的那一部分人

作者公众号：Tarzan写bug

Tarzan写bug
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
100行Java代码构建一个线程池
01-26
100行Java代码构建一个线程池
springboot如何创建全局线程池
qq_54421200的博客
01-17 585
bean，并设置了核心线程数、最大线程数、队列容量和线程名前缀。这个线程池将作为全局线程池，可以在你的应用中的任何地方使用。在Spring Boot中创建全局线程池，你可以通过配置一个。将这个线程池注入到需要它的类中。在这个例子中，我们创建了一个。
局部线程池和全局线程池_Linux线程池
weixin_34599904的博客
01-08 1416
什么是池？池是一组资源的集合，这组资源在服务器启动之初就被创建并初始化开始处理客户请求的时候，如果它需要相关的资源，就可以直接从池中获取服务器处理完一个客户连接后，可以把相关的资源放回池中分享一个手写实现线程池的视频：150行代码写个线程池为什么要创建线程池？当有客户端连接时，创建耗时为：线程时间+处理时间+销毁线程时间(耗时T1+T2+T3)若需要大量的线程来完成任务，且完成任务的时间比较短，这...
java 全局线程,线程池java,java创建全局的线程池
weixin_39671405的博客
03-14 1418
线程池java,java创建全局的线程池,java线程池之一：创建线程池的方法在Java开发过程中经常需要用到线程，为了减少资源的开销，提高系统性能，Java提供了线程池，即事先创建好线程，如果需要使用从池中取即可，Java中创建线程池有以下的方式，1、使用ThreadPoolExecutor类2、使用Executors类其实这两种方式在本质上是一种方式，都是通过ThreadPoolExecuto...
全局线程池
weixin_44074051的博客
12-05 429
在处理导入导出exel的时候，如果数据比较多需要开启线程池来加快处理速度。单独设置线程池很耗费时间，而且代码丑陋，我们可以通过公共线程池来解决这一问题。需要多线程调用方法对应的工具类：MutiThreadUtil.java。线程池配置类：ThreadToolConfig.java。
多线程（按时间段多个线程并发执行）
long198861的博客
01-13 590
1.###首先引入pom文件 <dependency> <groupId>com.alibaba</groupId> <artifactId>transmittable-thread-local</artifactId> <version>2.10.2</version> </dependency> 2.编写一个抽象类 IntervalRunnable，定义方法run packa
java 全局线程池_java 线程池（线程的复用）
weixin_36221082的博客
02-13 2940
一. 线程池简介1. 线程池的概念：线程池就是首先创建一些线程，它们的集合称为线程池。使用线程池可以很好地提高性能，线程池在系统启动时即创建大量空闲的线程，程序将一个任务传给线程池，线程池就会启动一条线程来执行这个任务，执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。2. 线程池的工作机制2.1 在线程池的编程模式下，任务是提交给整个线程池，而不是直接提交给某...
java 全局线程池,java的线程池的使用
weixin_39543655的博客
03-14 452
1、线程池的创立1、首先创立一个类，然后完成Runnable接口publicclassExectorTestimplementsRunnable{}2、首先声明一个线程池的全局变量publicclassExectorTestimplementsRunnable{//线程池privateExecutorServiceexecutorPool;}3、然后在run()办法中，创立线程池实例，创立线程池的...
Java并发编程系列之二十五：线程池
rhwayfun专栏
04-07 4857
线程池简介在之前介绍Executor框架的文章中对线程池有一个初步的认识，实际上线程池这种设计思想在Java中很普遍，比如JVM中常量池，以及Web开发使用到的数据库连接池。这些池本质上还是Java中的对象池，因为池中存放的都是Java对象。回到线程池，几乎所有需要异步或者执行并发任务的程序都可以使用到线程池。使用线程池带来的好处主要包括以下几个方面： 一，提高资源利用率。由于线程池中的线程使可
JAVA多线程并发操作全局变量
08-10
NULL 博文链接：https://toknowme.iteye.com/blog/2212529
一个完整的线程池的实例
05-06
所以源代码都有 ，一个完整的线程池的实例
java线程池使用后到底要关闭吗
08-26
主要给大家介绍了关于java线程池使用后到底要不要关闭的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Python基础——全局变量与局部变量
12-21
全局变量 1.局部变量 在 def 中, 我们可以定义一个局部变量, 这个变量 a 只能在这个功能 fun 中有效, 出了这个功能, a 这个变量就不是那个局部的 a. def fun(): a = 10 print(a) return a+90 print(fun()) 下面...
java全局异常统一处理
11-13
在Java中，全局异常统一处理是一种常见的错误处理模式，它允许在一个单独的地方集中处理应用程序中抛出的所有异常。这种处理方式有助于简化代码，提高代码的可读性和可维护性。 要实现全局异常统一处理，Java提供了...
Java Jmeter全局变量设置过程图解
08-19
主要介绍了Java Jmeter全局变量设置过程图解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
JAVA 自定义异常 全局捕获
12-04
自己编写异常类型 ，自定义错误异常进行全局捕捉。实现项目全局的拦截定义输出。。。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 1111
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
链表刷题集
最新发布
yajunjiao的专栏
04-30 483
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
java 全局线程池的创建及使用
06-03
Java全局线程池的创建和使用可以通过Java Executor框架来实现。以下是使用Java Executor框架创建和使用全局线程池的步骤： 1. 导入Java Executor框架的类库 在Java程序中，需要导入Java Executor框架的类库，以便使用其中的类和方法。 ``` import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; ``` 2. 创建全局线程池 使用Java Executor框架中的Executors类的静态方法，可以创建全局线程池。 ``` ExecutorService executor = Executors.newFixedThreadPool(10); ``` 这里创建了一个大小为10的线程池。 3. 执行任务 创建全局线程池后，可以将任务提交给线程池执行。可以使用execute方法提交任务。 ``` executor.execute(new Runnable() { public void run() { // 执行具体的任务逻辑 } }); ``` 这里使用匿名类实现Runnable接口，然后将任务提交给线程池。 4. 关闭线程池 当不再需要使用全局线程池时，需要将线程池关闭。可以使用shutdown方法关闭线程池。 ``` executor.shutdown(); ``` 以上就是Java全局线程池的创建和使用的步骤。需要注意的是，创建全局线程池时需要根据实际需求选择合适的线程池大小，以免过多的线程占用系统资源。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值