基于Java线程池的多线程运行器工具类

已于 2024-08-08 13:32:27 修改
阅读量192 收藏
点赞数 1
文章标签： java 线程池 Lambda 异步 多任务处理
于 2024-08-07 16:42:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xhom_w/article/details/140995716
版权
1.多线程运行器
package com.visy.utils;

import com.google.common.util.concurrent.ThreadFactoryBuilder;
import lombok.Getter;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;

/**
 * 多线程运行器
 * @author visy.wang
 * @date 2024/8/7 13:07
 */
@Getter
public class MultiThreadRunner {
    /**
     * 线程池内线程命名前缀
     */
    private String prefix;
    /**
     * 核心线程数
     * 核心线程会一直存活，即使没有任务需要执行
     */
    private Integer corePoolSize;
    /**
     * 最大线程数
     * corePoolSize <= 当前线程数 < maxPoolSize，且任务队列已满时，线程池会创建新线程来处理任务
     * 当前线程数 = maxPoolSize，且任务队列已满时，线程池会拒绝处理任务而抛出异常（具体见拒绝策略RejectedExecutionHandler）
     */
    private Integer maxPoolSize;
    /**
     * 任务队列容量（阻塞队列）
     * 当前线程数 = corePoolSize，新任务会放在队列中排队等待执行
     */
    private Integer capacity;
    /**
     * 线程空闲时间
     * 当线程空闲时间达到keepAliveTime时，线程会退出，直到线程数量 = corePoolSize
     */
    private Long keepAliveTime;
    /**
     * 时间单位
     */
    private TimeUnit timeUnit;
    /**
     * 任务拒绝处理器
     * 两种情况会拒绝处理任务：
     *   1.当线程数已经达到maxPoolSize，且队列已满，会拒绝新任务
     *   2.当线程池被调用shutdown()后，会等待线程池里的任务执行完毕，再shutdown。
     *     如果在调用shutdown()和线程池真正shutdown之间提交任务，会拒绝新任务，线程池会调用“任务拒绝处理器”来处理这个任务
     */
    private RejectedExecutionHandler handler;
    /**
     * 线程池
     */
    private ThreadPoolExecutor pool;

    public static MultiThreadRunner builder(){
        return new MultiThreadRunner();
    }

    public MultiThreadRunner prefix(String prefix){
        if(pool == null){
            this.prefix = prefix;
        }
        return this;
    }
    public MultiThreadRunner corePoolSize(Integer corePoolSize){
        if(pool == null){
            this.corePoolSize = corePoolSize;
        }
        return this;
    }
    public MultiThreadRunner maxPoolSize(Integer maxPoolSize){
        if(pool == null){
            this.maxPoolSize = maxPoolSize;
        }
        return this;
    }
    public MultiThreadRunner capacity(Integer capacity){
        if(pool == null){
            this.capacity = capacity;
        }
        return this;
    }
    public MultiThreadRunner keepAliveTime(Long keepAliveTime){
        if(pool == null){
            this.keepAliveTime = keepAliveTime;
        }
        return this;
    }
    public MultiThreadRunner timeUnit(TimeUnit timeUnit){
        if(pool == null){
            this.timeUnit = timeUnit;
        }
        return this;
    }
    public MultiThreadRunner handler(RejectedExecutionHandler handler){
        if(pool == null){
            this.handler = handler;
        }
        return this;
    }

    /**
     * 创建运行器（创建内部持有的线程池）
     * @return 运行器
     */
    public synchronized MultiThreadRunner build(){
        if(pool != null){
            //线程池只创建一次
            return this;
        }
        pool = new ThreadPoolExecutor(
            corePoolSize==null ? corePoolSize=getCpuCores()*2 : corePoolSize, //核心线程数，默认CPU核心数的2倍
            maxPoolSize==null ? maxPoolSize=corePoolSize+1 : maxPoolSize, //最大线程数，默认核心线程数+1
            keepAliveTime==null ? keepAliveTime=0L : keepAliveTime, //线程空闲时间，默认0
            timeUnit==null ? timeUnit=TimeUnit.MILLISECONDS : timeUnit, //时间单位，默认毫秒
            new LinkedBlockingQueue<>(capacity==null ? capacity=100 : capacity), //阻塞队列长度，默认100
            prefix==null ? Executors.defaultThreadFactory() : new ThreadFactoryBuilder().setNameFormat(prefix+"-%d").build(),
            handler==null ? handler=new ThreadPoolExecutor.AbortPolicy() : handler //任务拒绝处理器，默认AbortPolicy
        );
        return this;
    }

	/**
     * 获取系统CPU核心数
     */
    public int getCpuCores(){
        return Runtime.getRuntime().availableProcessors();
    }

    /**
     * 线程池的线程数量
     * 如果线程池不销毁的话，线程池里的线程不会自动销毁，所以这个大小只增不减
     */
    public int getPoolSize(){
        return pool==null ? 0 : pool.getPoolSize();
    }

    /**
     * 获取活动的线程数
     * 即正在执行任务的线程数
     */
    public int getActiveCount(){
        return pool==null ? 0 : pool.getActiveCount();
    }

    /**
     * 关闭线程池
     */
    public void shutdown(){
        if(pool != null){
            pool.shutdown();
        }
    }

    /**
     * 执行单个异步任务（无返回）
     * @param executor 执行器
     * @return Future
     */
    public Future<Void> runAsync(Runnable executor){
        if(pool == null){
            return CompletableFuture.runAsync(executor);
        }
        return CompletableFuture.runAsync(executor, pool);
    }

    /**
     * 执行多个异步任务（无返回）
     * @param list 任务列表
     * @param executor 执行器
     * @return Future列表
     * @param <U> 输入类型
     */
    public <U> List<Future<Void>> runAsync(List<U> list, Consumer<U> executor){
        return list.stream().map(item -> {
            return runAsync(() -> executor.accept(item));
        }).collect(Collectors.toList());
    }

    /**
     * 执行单个异步任务（有返回）
     * @param executor 执行器
     * @return 持有输出结果的Future
     * @param <R> 输出类型
     */
    public <R> Future<R> supplyAsync(Supplier<R> executor){
        if(pool == null){
            return CompletableFuture.supplyAsync(executor);
        }
        return CompletableFuture.supplyAsync(executor, pool);
    }

    /**
     * 执行多个异步任务（有返回）
     * @param list 任务列表
     * @param executor 执行器
     * @return 持有输出结果的Future列表
     * @param <U> 输入类型
     * @param <R> 输出类型
     */
    public <U,R> List<Future<R>> supplyAsync(List<U> list, Function<U,R> executor){
        return list.stream().map(item -> {
            return supplyAsync(() -> executor.apply(item));
        }).collect(Collectors.toList());
    }

    /**
     * 等待单个异步任务执行完毕（无返回）
     * @param executor 执行器
     */
    public void awaitRunAsync(Runnable executor)
            throws ExecutionException, InterruptedException {
        runAsync(executor).get();
    }

    /**
     * 等待单个异步任务执行完毕（无返回），可设置超时时间
     * @param executor 执行器
     * @param timeout 超时时间
     * @param timeUnit 时间单位
     */
    public void awaitRunAsync(Runnable executor, long timeout, TimeUnit timeUnit)
            throws ExecutionException, InterruptedException, TimeoutException {
        runAsync(executor).get(timeout, timeUnit);
    }

    /**
     * 等待多个异步任务执行完毕（无返回）
     * @param list 任务列表
     * @param executor 执行器
     * @param <U> 输入类型
     */
    public <U> void awaitRunAsync(List<U> list, Consumer<U> executor)
            throws ExecutionException, InterruptedException {
        for (Future<Void> future : runAsync(list, executor)) {
            future.get();
        }
    }

    /**
     * 等待多个异步任务执行完毕（无返回），可设置超时时间
     * @param list 任务列表
     * @param executor 执行器
     * @param timeout 超时时间
     * @param timeUnit 时间单位
     * @param <U> 输入类型
     */
    public <U> void awaitRunAsync(List<U> list, Consumer<U> executor, long timeout, TimeUnit timeUnit)
            throws ExecutionException, InterruptedException, TimeoutException {
        for (Future<Void> future : runAsync(list, executor)) {
            future.get(timeout, timeUnit);
        }
    }

    /**
     * 等待单个异步任务执行完毕（有返回）
     * @param executor 执行器
     * @return 执行结果
     * @param <R> 输出类型
     */
    public <R> R awaitSupplyAsync(Supplier<R> executor)
            throws ExecutionException, InterruptedException {
        return supplyAsync(executor).get();
    }

    /**
     * 等待单个异步任务执行完毕（有返回），可设置超时时间
     * @param executor 执行器
     * @param timeout 超时时间
     * @param timeUnit 时间单位
     * @return 执行结果
     * @param <R> 输出类型
     */
    public <R> R awaitSupplyAsync(Supplier<R> executor, long timeout, TimeUnit timeUnit)
            throws ExecutionException, InterruptedException, TimeoutException {
        return supplyAsync(executor).get(timeout, timeUnit);
    }

    /**
     * 等待多个异步任务执行完毕（有返回）
     * @param list 任务列表
     * @param executor 执行器
     * @return 执行结果列表
     * @param <U> 输入类型
     * @param <R> 输出类型
     */
    public <U,R> List<R> awaitSupplyAsync(List<U> list, Function<U,R> executor)
            throws ExecutionException, InterruptedException {
        List<R> resultList = new ArrayList<>();
        for (Future<R> future : supplyAsync(list, executor)) {
            resultList.add(future.get());
        }
        return resultList;
    }

    /**
     * 等待多个异步任务执行完毕（有返回），可设置超时时间
     * @param list 任务列表
     * @param executor 执行器
     * @param timeout 超时时间
     * @param timeUnit 时间单位
     * @return 执行结果列表
     * @param <U> 输入类型
     * @param <R> 输出类型
     */
    public <U,R> List<R> awaitSupplyAsync(List<U> list, Function<U,R> executor, long timeout, TimeUnit timeUnit)
            throws ExecutionException, InterruptedException, TimeoutException {
        List<R> resultList = new ArrayList<>();
        for (Future<R> future : supplyAsync(list, executor)) {
            resultList.add(future.get(timeout, timeUnit));
        }
        return resultList;
    }
}
2.测试
package com.visy.utils;

import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Future;

/**
 * @author visy.wang
 * @date 2024/8/7 14:26
 */
@Slf4j
public class MultiThreadRunnerTest {
    //初始化多线程运行器
    //必须调用build()才能完成内部线程池的创建
    private static final MultiThreadRunner multiThreadRunner = MultiThreadRunner.builder()
    .prefix("test").corePoolSize(5).maxPoolSize(8).capacity(10).build(); 

    public static void main(String[] args) throws Exception {
        List<Integer> list = new ArrayList<>();
        for(int i=0; i<20; i++){
            list.add(i);
        }

        System.out.println("执行单个异步任务（无返回）");
        multiThreadRunner.runAsync(() -> {
            System.out.println(66);
        }).get();

        System.out.println("等待单个异步任务执行完毕（无返回）");
        multiThreadRunner.awaitRunAsync(() -> {
            System.out.println(77);
        });

        System.out.println("执行单个异步任务（有返回）");
        System.out.println(multiThreadRunner.supplyAsync(() -> 88).get());

        System.out.println("等待单个异步任务执行完毕（有返回）");
        System.out.println(multiThreadRunner.awaitSupplyAsync(() -> 99));

        System.out.println("执行多个异步任务（无返回）");
        for (Future<Void> future : multiThreadRunner.runAsync(list, i -> System.out.print((i + 1) + ";"))) {
            future.get();
        }

        System.out.println("\n等待多个异步任务执行完毕（无返回）");
        multiThreadRunner.awaitRunAsync(list, i -> System.out.print((i+2)+";"));

        System.out.println("\n执行多个异步任务（有返回）");
        List<Future<Integer>> futures = multiThreadRunner.supplyAsync(list, i -> i+3);
        for (Future<Integer> future : futures) {
            System.out.print(future.get()+";");
        }

        System.out.println("\n等待多个异步任务执行完毕（有返回）");
        multiThreadRunner.awaitSupplyAsync(list, i -> i+4).forEach(i -> {
            System.out.print(i+";");
        });

        //关闭任务执行器（注意：关闭后不能再执行任何任务）
        multiThreadRunner.shutdown();

        System.out.println("\n关闭后执行任务");
        multiThreadRunner.awaitRunAsync(() -> {
            System.out.println(999);
        });
    }
}
3.打印结果
执行单个异步任务（无返回）
66
等待单个异步任务执行完毕（无返回）
77
执行单个异步任务（有返回）
88
等待单个异步任务执行完毕（有返回）
99
执行多个异步任务（无返回）
3;1;5;6;2;8;9;11;7;4;15;12;14;13;10;19;18;17;16;20;
等待多个异步任务执行完毕（无返回）
2;3;6;8;5;4;11;10;9;7;16;15;13;12;20;21;19;14;18;17;
执行多个异步任务（有返回）
3;4;5;6;7;8;9;10;11;12;13;14;15;16;17;18;19;20;21;22;
等待多个异步任务执行完毕（有返回）
4;5;6;7;8;9;10;11;12;13;14;15;16;17;18;19;20;21;22;23;
关闭后执行任务
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task java.util.concurrent.CompletableFuture$AsyncRun@22f71333 rejected from java.util.concurrent.ThreadPoolExecutor@13969fbe[Terminated, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 84]
	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063)
	at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830)
	at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379)
	at java.util.concurrent.CompletableFuture.asyncRunStage(CompletableFuture.java:1654)
	at java.util.concurrent.CompletableFuture.runAsync(CompletableFuture.java:1871)
	at com.server.utils.MultiThreadRunner.runAsync(MultiThreadRunner.java:173)
	at com.server.utils.MultiThreadRunner.awaitRunAsync(MultiThreadRunner.java:222)
	at com.server.utils.MultiThreadRunnerTest.main(MultiThreadRunnerTest.java:69)

Process finished with exit code 1
咘噜biu
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java 利用多线程实现文件的分片下载
01-15
Main方法是运行开始的方法，里面StopWatch是测速工具类，如果要想使用请导入相关maven坐标，不想使用直接删除即可。 内容概要： 这是随手写的一个利用线程池下载文件的小玩具，如果刚学完线程池不知道怎么使用的，...
Java中的线程与线程池.pptx
01-20
Java提供了Executors工具类来创建不同类型的线程池： 1. newCachedThreadPool：创建一个可缓存线程池，线程空闲超过指定时间后会被回收，当线程池为空时，会新建线程来处理任务。 2. newSingleThreadExecutor：创建...
Java多线程案例之线程池
trong_ 的烂笔头
01-30 5472
介绍线程池的原理和简单实现, 进一步提高并发编程的效率.
Java线程池及线程池工具类
尘风yf的博客
11-10 3794
Java线程池工具类线程池介绍线程池使用及参数介绍线程池使用线程池参数介绍七大核心参数等待队列拒绝策略线程池执行流程线程池工具类创建线程池newFixedThreadPoolnewSingleThreadExecutornewCachedThreadPoolnewScheduledThreadPoolnewSingleThreadScheduledExecutornewWorkStealingPool自定义异常处理器 线程池介绍 启动一个新线程涉及与操作系统交互，成本比较高。线程池在程序启动时创建大量空闲线
浅谈Java线程池中的ThreadPoolExecutor工具类
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
02-21 1696
ThreadPoolExecutor七个核心参数，线程池的工作流程分析
深入理解Java的线程池与线程工具类
禅与计算机程序设计艺术
01-28 750
1.背景介绍 1. 背景介绍 Java的线程池和线程工具类是Java并发编程中不可或缺的组件。线程池可以有效地管理和重复利用线程，提高程序的性能和效率。线程工具类则提供了一系列用于操作和管理线程的方法，使得开发者可以更加轻松地处理并发问题。 在本文中，我们将深入探讨Java的线程池和线程工具类的核心概念、算法原理、最佳实践以及实际应用场景。同时，我们还将分析一些常见的问题和解答，以帮助读者更...
Java多线程实战-从零手搓一个简易线程池(一)定义任务等待队列
qq_35716689的博客
03-25 18万+
开个新坑-手搓简易线程池。本系列文章将从零开始,一步步手工编码实现一个简单但功能完备的线程池。我们将逐步介绍线程池的各个核心组件,并分析它们的作用和实现思路。通过这个过程,我们可以更好地掌握多线程编程的技巧,并培养编码能力和系统性思维。
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 18万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
java多线程之线程池
程序三两行
06-30 4282
在执行一个异步任务或并发任务时，往往是通过直接new Thread()方法来创建新的线程，这样做弊端较多，更好的解决方案是合理地利用线程池，线程池的优势很明显，如下： 降低系统资源消耗，通过重用已存在的线程，降低线程创建和销毁造成的消耗...
Java多线程实战-从零手搓一个简易线程池(二)线程池实现与拒绝策略接口定义
qq_35716689的博客
03-27 17万+
在前面的文章中，我们讲解了任务堵塞队列的实现，这篇文章会基于任务堵塞队列实现一个简易的线程池，在后续的文章中，还会继续对本章编写的线程池进行功能扩展和优化。
Java多线程-线程池
weixin_45203607的博客
10-03 922
Java多线程-线程池 线程池的作用 线程池作用就是限制系统中执行线程的数量。 根 据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排 队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池 中有等待的工作线程，就可以开始运行了；否则进入等待队列。 我们先来了解一下Executors 和 ExecutorService 下表列
JAVA多线程技术-线程池创建方式和原理
Aldeo
07-19 1694
Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService。下面这张图完整描述了线程池的类体系结构。**Executor**一个接口，其定义了一个接收Runnable对象的方法executor，其方法签名为executor(Runnablecommand),一个可定时调度任务的接口。...
Java多线程下载器
09-26
Java多线程下载器是一种利用Java编程语言实现的高效文件下载工具，它通过将大文件分割成多个部分并同时下载，显著提高了下载速度。在Java中实现多线程下载器涉及许多关键概念和技术，包括线程、并发控制、网络I/O...
Springboot实现多线程注入bean的工具类操作
09-07
为了解决这个问题，我们可以创建一个工具类，如`ApplicationContextProvider`，用于在多线程场景中获取所需的bean。 `ApplicationContextProvider`实现了`ApplicationContextAware`接口，这个接口是Spring提供的一...
线程池管理多线程上传
01-15
线程池管理和多线程上传是并发编程中的一个重要实践，特别是在大数据传输和网络服务中。在Java等编程语言中，线程池通过有效地管理和复用线程资源，避免了频繁创建和销毁线程带来的开销，提升了系统性能。下面将详细...
C++ - 函数重载
最新发布
jiaowenjie的专栏
08-06 264
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
枚举工具类
qq_43049583的博客
08-04 484
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
泰勒今天想展开的博客
08-04 561
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
时光不等人：java每日一练
m0_67187271的博客
08-05 1039
时光悄然流逝，不等人。技术亦不会自来门前，唯有勤奋学习，方能抓住时代的脉搏。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值