简化Java多线程编程的实用利器!

ThreadUtil通过封装Java标准库中的ExecutorService、CountDownLatch等并发工具，提供了一系列简洁易用的方法。

1. 1. 异步执行任务（excuteAsync）
2. •
3. ThreadUtil(excuteAsync)
4. 方法允许开发者以异步方式执行任务，避免阻塞主线程。
5. • • 示例代码：
   • 

• • 该方法返回一个Future对象，可以通过调用get()方法获取任务结果。

1. 2. 在公共线程池中执行任务（execute）
2. • • ThreadUtil.execute()方法直接在公共线程池中执行任务，无需手动创建线程池。
   • • 示例代码：
   • 

• • 这种方式适合需要频繁执行小任务的场景。

1. 3. 创建新的线程池（newExecutor）
2. •
3. ThreadUtil.newExecutor()
4. 方法允许开发者创建自定义的线程池，并设置核心线程数和最大线程数。
5. • 

• • 通过这种方式，可以更好地控制线程资源的分配。

1. 4. 等待一组线程完成（newCountDownLatch）
2. •
3. ThreadUtil.newCountDownLatch(int count)
4. 方法创建一个
5. CountDownLatch
6. 对象，用于等待一组线程完成。
7. • 

• • 这种方式适用于需要同步多个子任务的场景。

1. 5. 挂起当前线程（sleep）
2. •
3. ThreadUtil.sleep(long time)
4. 方法封装了
5. Thread.sleep()
6. ，可以安全地挂起当前线程。
7. • 

• • 该方法避免了因未正确处理中断信号而导致的异常。

1. 6. 获取当前线程信息（ currentThread）
2. •
3. ThreadUtil.currentThread()
4. 方法返回当前线程的实例。
5. • 

• • 该方法便于开发者获取当前线程的信息并进行调试。

1. 7. 结束线程（interrupt）
2. •
3. ThreadUtil.interrupt(Thread thread)
4. 方法可以安全地中断指定的线程。
5. • 

• • 该方法确保了中断信号的正确处理。

1. 8. 获取线程堆栈信息（getStack trace）
2. •
3. ThreadUtil.getStack trace(Thread thread)
4. 方法返回指定线程的堆栈信息。

• • 该方法便于开发者分析线程运行时的状态。

我们通过一个简单的业务场景来演示其使用方法。订单处理需要调用多个异步服务，并在所有服务完成后返回结果。

代码实现：

import cn.hutool.core.util.ThreadUtil;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CountDownLatch;

publicclassOrderProcessor {
    publicstaticvoidmain(String[] args)throws InterruptedException {
        // 创建一个CountDownLatch对象，用于等待所有子任务完成
        CountDownLatchlatch=newCountDownLatch(3);

        // 异步调用三个服务
        CompletableFuture<Void> future1 = ThreadUtil(excuteAsync(() -> {
            System.out.println("服务1开始执行");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("服务1执行完成");
            latch.countDown();
        }));

        CompletableFuture<Void> future2 = ThreadUtil(excuteAsync(() -> {
            System.out.println("服务2开始执行");
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("服务2执行完成");
            latch.countDown();
        }));

        CompletableFuture<Void> future3 = ThreadUtil(excuteAsync(() -> {
            System.out.println("服务3开始执行");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("服务3执行完成");
            latch.countDown();
        }));

        // 等待所有服务完成
        latch.await();

        System.out.println("所有服务已完成，开始汇总结果");
    }
}

运行结果：

如果这篇文章对您有所帮助，或者有所启发的话，求一键三连：点赞、转发、在看。

关注公众号：woniuxgg，在公众号中回复：笔记 就可以获得蜗牛为你精心准备的java实战语雀笔记，回复面试、开发手册、有超赞的粉丝福利！