使用多线程执行任务，并获取返回结果，附异步实现

最新推荐文章于 2024-05-28 12:59:42 发布
最新推荐文章于 2024-05-28 12:59:42 发布
阅读量6.8k 收藏 11
点赞数 4
分类专栏： 多线程 文章标签： java jvm servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/delete_bug/article/details/130544438
版权

1 获取又返回结果的 需要用到 callable接口

public class TestTask implements Callable<Student> {
    @Override
    public Student call() throws Exception {
        Thread.sleep(1500);
        Student student = new Student();
        student.setAge(10);
        student.setName("里里");
        System.out.println("线程执行"+student.toString());
        return student;
    }
}

@Data
public class Student {
    private String name;
    private Integer age;
}

2 创建一个线程池，可以用自定义线程池，也可以直接用那四种线程池

这里创建了一个包含三个线程的固定线程池

 ExecutorService executorService = Executors.newFixedThreadPool(3);
 Future<Student> future = executorService.submit(new TestTask());
 try {
            if (!future.isDone()) {
                System.out.println("Task is processing now, please wait...");
            }
            Student result = future.get();
            System.out.println("Result is: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }

线程池的介绍
根据主机情况实现自定义线程池：

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public class CustomThreadPool {
    // 线程池大小
    private final int poolSize;
    // 任务队列
    private final BlockingQueue<Runnable> taskQueue;
    // 线程数组
    private final Thread[] threads;

    /**
     * 构造函数
     * @param poolSize 线程池大小
     */
    public CustomThreadPool(int poolSize) {
        this.poolSize = poolSize;
        this.taskQueue = new LinkedBlockingQueue<>();
        this.threads = new Thread[poolSize];

        for (int i = 0; i < poolSize; i++) {
            threads[i] = new WorkerThread();
            threads[i].start();
        }
    }

    /**
     * 提交任务
     * @param task 任务
     */
    public void execute(Runnable task) {
        synchronized (taskQueue) {
            taskQueue.offer(task);
            taskQueue.notify();
        }
    }

    /**
     * 关闭线程池
     */
    public void shutdown() {
        for (int i = 0; i < poolSize; i++) {
            threads[i].interrupt();
        }
    }

    /**
     * 工作线程
     */
    private class WorkerThread extends Thread {
        public void run() {
            Runnable task;

            while (!Thread.currentThread().isInterrupted()) {
                try {
                    task = taskQueue.poll(500, TimeUnit.MILLISECONDS);
                } catch (InterruptedException e) {
                    break;
                }

                if (task != null) {
                    task.run();
                }
            }
        }
    }
}

也可以通过继承 ThreadPoolExecutor 类来实现一个自定义线程池工具类。ThreadPoolExecutor 是 Java 标准库中提供的一个线程池实现，通过继承它，我们可以实现自定义的线程池。

下面是一个继承 ThreadPoolExecutor 的自定义线程池工具类的实现：

import java.util.concurrent.*;

public class CustomThreadPool extends ThreadPoolExecutor {
    public CustomThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

    public static CustomThreadPool newThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, int queueSize) {
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(queueSize);
        return new CustomThreadPool(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        super.beforeExecute(t, r);
        // 在执行任务前的操作
    }

    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        // 在执行任务后的操作
    }

    @Override
    protected void terminated() {
        super.terminated();
        // 线程池关闭时的操作
    }
}

在构造函数中，我们调用了父类 ThreadPoolExecutor 的构造函数，用于初始化线程池的一些参数，包括线程池的大小、任务队列、线程池的最大大小、线程存活时间等等。

我们还实现了一个静态方法 newThreadPool()，用于创建一个新的线程池。这个方法接收线程池的核心大小、最大大小、线程存活时间、时间单位和任务队列的大小等参数，然后创建一个 ArrayBlockingQueue 作为任务队列，然后通过父类的构造函数创建一个新的线程池。

在这个自定义线程池工具类中，我们还重写了三个方法：

  1. beforeExecute()：在线程执行任务前执行的方法，可以在这里进行一些初始化操作。
  2. afterExecute()：在线程执行任务后执行的方法，可以在这里进行一些清理操作。
  3. terminated()：在线程池关闭时执行的方法，可以在这里进行一些资源释放操作。

这些方法可以根据需要进行重写。

使用这个自定义线程池工具类时，可以通过调用 execute() 方法来提交任务，如下所示：

CustomThreadPool pool = CustomThreadPool.newThreadPool(5, 10, 60L, TimeUnit.SECONDS, 100);

for (int i = 0; i < 10; i++) {
    final int taskNum = i;
    pool.execute(() -> {
        System.out.println("Task " + taskNum + " is running.");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Task " + taskNum + " is completed.");
    });
}

pool.shutdown();

这里我们创建了一个新的线程池，并提交了一些任务。在任务执行时，我们通过重写 beforeExecute() 和 afterExecute() 方法，可以在任务执行前后进行一些操作。在线程池关闭时，我们可以通过重写 terminated() 方法来进行一些资源释放操作

在Java中，执行线程任务通常有两种方式：使用 execute 方法或使用 submit 方法。它们的区别在于：

返回值不同：execute 方法没有返回值，而 submit 方法返回一个 Future 对象。
异常处理不同：如果在执行任务时抛出异常，execute 方法会打印出异常堆栈信息，并且不会捕获异常，而 submit 方法会将异常封装到返回的 Future 对象中，可以通过调用 Future.get() 方法获取异常信息。
任务提交方式不同：execute 方法是将任务直接提交给线程池，而 submit 方法则是将任务封装成一个 Callable 对象，并将其提交给线程池。
因此，如果我们需要对线程执行的结果进行控制并捕获异常，可以使用 submit 方法，如果我们只是需要简单地提交一个任务给线程池，可以使用 execute 方法。

3 使用CompletionService

CompletionService是Java提供的一种辅助类，它可以用于管理多个Future对象并发执行的结果。CompletionService可以帮助我们避免手动迭代多个Future来获取结果的麻烦，并且可以让我们更方便地处理多个任务的执行结果。

CompletionService最常用的方法是submit(Callable<T> task)和take()。通过submit方法，我们可以提交一个任务到该CompletionService中，并返回一个与该任务关联的Future对象。这个Future对象可以用来获取任务的结果。但是，与直接使用ExecutorService不同，CompletionService会将结果保存到一个阻塞队列中，使用take()方法可以从阻塞队列中取得第一个完成的任务的结果。

举个例子来说，如果有一个任务列表，我们需要依次异步执行，或者说需要一次性获取所有任务的执行结果，这种情况下可以使用CompletionService。在这个场景下，我们可以将所有任务提交到CompletionService中，然后使用take()方法取出队列中的任务结果。这样可以在处理每个任务的同时，按照完成时间顺序获取任务的结果。

以下是一个使用CompletionService实现同时处理多个任务的代码示例：

import java.util.concurrent.*;

public class CompletionServiceDemo {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executor = Executors.newCachedThreadPool();
        CompletionService<Integer> completionService = new ExecutorCompletionService<>(executor);
        for (int i = 0;i < 10; i++) {
            final int finalI = i;
            completionService.submit(() -> finalI);
        }

        for (int i = 0;i < 10; i++) {
            int result = completionService.take().get();
            System.out.println("Finished task " + result);
        }

        executor.shutdown();
    }
}

上述代码中，我们先定义ExecutorService（线程池），然后将其传入ExecutorCompletionService。接着，我们通过submit()方法将任务放入CompletionService中。最后，在主线程中通过循环调用take()方法来获取结果，因为结果会按照完成时间顺序被加入队列，所以可以方便的保证结果的顺序性。

结合我们的案例：

public class Test {
    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newFixedThreadPool(3);

       // Future<Student> future = executorService.submit(new TestTask());

        CompletionService completionService = new ExecutorCompletionService(executorService);

        for (int i = 0; i <5 ; i++) {
            completionService.submit(new TestTask());
        }

        for (int i = 0; i < 5; i++) {
            System.out.println(completionService.take().get());
        }

        /*try {
            if (!future.isDone()) {
                System.out.println("Task is processing now, please wait...");
            }
            Student result = future.get();
            System.out.println("Result is: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }*/
    }
}

4 异步

异步和多线程一样，都是为了让程序运行效率更高

多线程指的是在一个程序中同时运行多条线程，这些线程相互独立，可以执行不同的任务。通过多线程，我们可以实现并发处理，提高程序的执行效率。

异步则是一种编程模型，指的是一个任务的执行不需要等待其他任务的结束，而是可以继续执行其他任务或者返回结果。异步通常使用回调函数或者事件驱动来实现。

在实际应用中，多线程和异步经常一起使用来处理并发问题。例如，在一个网络请求中，我们可以使用异步方式向服务器发起请求，同时使用多线程方式处理服务器响应的数据。这样可以提高请求的处理速度，同时也不会阻塞主线程的执行。

实操：

实现方式一 使用@Async注解

在Spring Boot应用中，我们可以使用Spring提供的@Async注解来指定一个方法为异步方法。使用该注解后，Spring会在调用该方法时在另外一个线程中执行方法，并立即将控制权返回给调用方
需要注意的是，在使用@Async注解时，我们需要在应用的配置类上加上@EnableAsync注解，开启Spring的异步机制。示例代码如下：

@Configuration
@EnableAsync
public class AppConfig {
 
    // 配置异步线程池等等相关配置...
 
}

这里我试过了，在异步方法的bean 或者是在启动类上加这个注解都可以实现异步功能，但是如果不加Enable注解的话，只有@Async注解是不能实现异步功能的。
在这里插入图片描述
在这里插入图片描述

这两处地方都可以。
另外，异步是真异步，怎么讲呢

@RequestMapping("/hello2")
    public String hello2() throws InterruptedException {
        long start = System.currentTimeMillis();
        Thread.sleep(2000);

        String result = testRetryService.hh();
        long end = System.currentTimeMillis();
        System.out.println("执行耗时"+((end-start)/1000));
        return result;
    }

 @Async
    public String hh() throws InterruptedException {
        Thread.sleep(5000);
        System.out.println("异步方法输出");
        return "Hello";
    }

即使我再结果中返回异步执行的结果，他并不会等待异步任务完成再返回，也就是上述代码，在调用接口两秒后就返回（返回为空，因为并没有获取到异步的执行结果异步执行耗时长），并不是七秒。

实现方式二
使用CompletableFuture
除了使用@Async注解以外，Spring Boot还支持Java 8中的CompletableFuture来实现异步操作。CompletableFuture是一种非常强大、灵活的异步编程工具，可以方便地实现链式异步处理。

示例代码如下：

public class AsyncService {
 
    public CompletableFuture<String> doTask1() {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 异步执行的任务1
            return "Result1";
        });
        return future;
    }
    
    public CompletableFuture<String> doTask2() {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 异步执行的任务2
            return "Result2";
        });
        return future;
    }
}

在上述代码中，我们首先使用CompletableFuture的supplyAsync方法将一个Lambda函数包装为异步执行的任务，并返回一个CompletableFuture对象。接着，我们可以在需要异步执行的地方使用该方法，结合其他的CompletableFuture方法（如thenCompose()、thenApply()等）进行链式处理。

需要注意的是，使用CompletableFuture时，你需要手动指定线程池来执行异步任务。示例代码如下：

public class AsyncService {
    private static final Executor executor = Executors.newFixedThreadPool(5); // 线程池
    
    public CompletableFuture<String> doTask1() {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 异步执行的任务1
            return "Result1";
        }, executor);
        return future;
    }
    
    public CompletableFuture<String> doTask2() {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 异步执行的任务2
            return "Result2";
        }, executor);
        return future;
    }
}

附一篇文章，关于实现异步的几种方式：
面试官：实现异步的8种方式，你知道几个？

凌晨里的无聊人
关注
  • 4
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
硬核解析：Java线程-如何优雅地获取线程的执行结果
wdj_yyds的博客
07-20 378
Future接口5个方法：java复制代码// 取消任务 boolean cancel(boolean mayInterruptIfRunning);// 判断任务是否已取消 boolean isCancelled();// 判断任务是否已结束 boolean isDone();// 获得任务执行结果 阻塞，被调用时，如果任务还没有执行完，那么调用get()方法的线程会阻塞。直到任务执行完 // 才会被唤醒 get();
如何获取线程的返回值？
悦悦的狗子
06-22 5553
获取线程的返回值 主线程等待法，主线程调用sleep方法（让主线程去循环等待子线程结束并赋值；缺点：代码臃肿，等待时间无法精准控制；不推荐使用）； 使用Thread类的join()阻塞当前线程以等待子线程处理结束（不能精准控制多个线程中的其中一个；不推荐使用）； 通过Callable接口实现call()获取线程返回值（通过FutrueTask Or 线程池获取，推荐使用） FutrueTask的构造方法可以传入Callable实现类的实例； isDone()可以判断call是否执行结束；
java异步线程获取返回值
qq_18684463的博客
04-17 587
本文提供异步线程获取返回值的方法
线程池-提交线程获与取线程执行结果
最新发布
存在,即合理
05-28 574
不见不散过时不候轮询。
使用多线程来执行任务，最终将结果汇总
张火火博客
11-08 2843
第一种 ：future.get();因为是按照提交顺序返回结果的，所以会造成阻塞。第二种：completionService.take().get()；是按谁完成谁先返回结果，放到一个队列里再取数据，只会在取数据时没有数据的时候阻塞。记得还有其他的实现方式，也是根据future来返回结果。实现callable接口。
多线程并发执行任务，取结果归集。终极总结：Future、FutureTask、CompletionService、CompletableFuture
zdy0_2004的专栏
06-20 8793
http://www.cnblogs.com/dennyzhangdd/p/7010972.html 目录 1.Futrue 2.FutureTask 3.CompletionService 4.CompletableFuture 5.总结 ================正文分割线================= 开启线程执行
Java 获取多线程返回值的几种方式
m0_48324758的博客
06-13 8991
Java获取多线程返回值的几种方式
【并发编程】- 线程池执行Callable任务获取返回值
老男孩的架构路
08-09 3825
针对线程Thread对象不具有返回值的功能，但是有请求需要线程返回值，所以需要用到Callable和Future来让线程具有返回值的功能。Callable接口与线程密不可分，但是和Runnable有以下主要的区别是Callable接口的call()方法可以有返回值，而Runnable接口的run()方法没有返回值。Callable接口的call()方法可以声明抛出异常，而Runnable接口的run()方法不可以声明抛出异常。...
通过多线程任务处理大批量耗时业务并返回结果
11-16
标题中的"通过多线程任务处理大批量耗时业务并返回结果"指的是在Java或其他支持多线程的编程语言中，如何有效地分配工作到多个线程，以便同时处理大量任务，并在任务完成后收集和处理结果。 描述中提到的"当监测到...
Java多线程实现异步调用的方法
09-03
总结来说，Java通过多线程和异步调用来提升程序的并发性能，利用 `Future` 或 `CompletableFuture` 等工具进行结果的获取和管理，结合 `ExecutorService` 管理线程，可以构建出高效、灵活的异步处理系统。...
实现PHP多线程异步请求的3种方法
10-26
在PHP中实现多线程异步请求是许多开发者在处理并发任务时的需求。虽然PHP本身并不支持原生的多线程，但可以通过一些技巧和扩展来模拟实现这一功能。以下是文章中提到的三种常用方法： 1. **使用CURL实现异步请求** ...
C++多线程获取返回值方法详解
08-19
主要介绍了C++多线程获取返回值方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
浅谈Java获得多线程的返回结果方式(3种)
08-19
Java 多线程返回结果方式详解 在 Java 中，获取多线程的返回结果是一件复杂的事情。今天，我们将介绍三种方式来获取多线程的返回结果。 第一种方法：使用 Runnable 实现类 在这个方法中，我们可以在 Runnable 的...
Java利用future及时获取多线程运行结果
08-29
首先，定义一个多线程执行任务的类AsyncThread，里面包含三个方法：generate、doOtherThings和getResult。generate方法用于生成指定数量的线程，都放入future数组中；doOtherThings方法用于处理其他事情，例如打印...
java中获取线程返回值的几种方式
Goals1989的博客
01-17 3689
在之前的工作中，主要是写业务代码，线程使用得很少，也没有考虑执行线程后如何获取返回值的问题，而线程中的run()方法是没有返回值的。那如果在线程执行完毕后想要获取对应的值要怎么做？借着最近的学习总结一下。线程返回值主要有几种方式。下面通过demo做一下演示以上代码因为MyThreadReturn线程需要5秒执行完毕，主线程中并不能顺利获取到returnValue将代码做如下修改。
如何获取线程返回结果
贾廷帅的博客
12-19 3195
如何获取线程返回结果前言：1.思路2.获取线程调用返回值小结 前言： 我们知道 Thread.run() 返回值是 void, 那么当我们通过多线程执行任务的时候，如果想获取线程的返回值， 应该怎么做呢？思路是什么？ 1.思路 如果你看过《Thread.start()之后是如何调用 run()方法的呢？ 》 这篇文章，会知道当线程启动之后，最终操作系统会回调 Thread.run() 方法。那么我们就可以在 Thread.run() 方法里面做文章。比如我们写了一个类实现了Runnable接口， publi
Java CompletableFuture实现多线程异步编排
m0_73311735的博客
09-07 983
在Java 8中, 新增加了一个包含50个方法左右的类: CompletableFuture，提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合CompletableFuture的方法。CompletableFuture类实现了Future接口，所以你还是可以像以前一样通过get方法阻塞或者轮询的方式获得结果，但是这种方式不推荐使用。
java web 异步调用_java中异步调用注意
weixin_35823403的博客
02-16 331
Future接口是Java标准API的一部分，在java.util.concurrent包中。Future接口是Java线程Future模式的实现，可以来进行异步计算。有了Future就可以进行三段式的编程了，1.启动多线程任务2.处理其他事3.收集多线程任务结果。从而实现了非阻塞的任务调用。在途中遇到一个问题，那就是虽然能异步获取结果，但是Future的结果需要通过isdone来判断是否有结果，...
ExecutorService实现获取线程返回值
热门推荐
Mannggo
01-15 1万+
什么是ExecutorService? ExecutorService是java.util.concurrent包中的一个线程池实现接口。其有两个实现类：ThreadPoolExecutor 和 ScheduledThreadPoolExecutor。分别用来实现普通线程池和延迟任务线程池。普通线程池通过配置线程池大小，能有效管理线程的调度，在执行大量异步线程时提高程序的性能。延迟任务线程池可控
java异步执行多线程任务，执行完每个任务返回状态
05-19
在Java中，可以使用线程池来异步执行多线程任务，并且可以通过Future或CompletableFuture来获取每个任务的执行结果。 下面是一个使用CompletableFuture的示例代码： ```java ExecutorService executor = Executors...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

凌晨里的无聊人

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值