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

这篇具有很好参考价值的文章主要介绍了使用多线程执行任务,并获取返回结果,附异步实现。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

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注解是不能实现异步功能的。
java多线程future异步返回,多线程,java,jvm,servlet
java多线程future异步返回,多线程,java,jvm,servlet

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

@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种方式,你知道几个?文章来源地址https://www.toymoban.com/news/detail-602418.html

到了这里,关于使用多线程执行任务,并获取返回结果,附异步实现的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • bat 获取手机SN & 处理adb cmd 返回结果-(For 中执行多条cmd 的用法)

    tips: ①对应的 Notepad++ 的快捷键为 Ctrl+k (单行、多行注释) Ctrl+q (区块注释)         参数作为输出参数时,注意:                 ★函数内不要使用SETLOCAL和ENDLOCAL                 ★此文件不要设置setlocal enabledelayedexpansion  执行结果: 执行结果:

    2024年02月15日
    浏览(31)
  • Java:使用java调用shell命令并获取返回结果的代码

           如下提供一段简单的使用java调用shell命令并获取返回结果的代码,其中有获取正常返回结果和异常返回结果的处理方法,在实际使用时可根据实际情况进行调整。 调用此方法时传入实际执行的shell命令即可:

    2024年02月12日
    浏览(23)
  • Flutter实现ControlExecutor进行多个异步任务执行时监听状态并可指定最后执行的异步并在指定的异步执行完毕后结束executor并回调。

    1.场景 当有多个接口请求时,且接口调用不是同时进行时,而且接口调用有可能时链式的,中间也有可能加入别的逻辑,但是需要在第一个接口调用时打开等待框,在最后一个接口调用完成时关闭等待框类似需求时,可以用到ControlExecutor进行接口执行过程的监听,并可标记最

    2024年02月09日
    浏览(24)
  • for循环内线程池并发执行任务,等到子线程全部处理完任务,主线程在执行java的实现方式

    for循环内线程池并发执行任务,等到子线程全部处理完任务,主线程在执行 方式一 使用 CountDownLatch 在 Java 中,您可以使用 CountDownLatch 来实现主线程等待子线程执行完成的功能。CountDownLatch 是一个同步工具类,它允许一个或多个线程等待其他线程完成操作后再继续执行。 具

    2024年02月11日
    浏览(31)
  • 微信小程序使用自定义tabbar 想要获取tabbar的高度,返回的结果是null,该如何获取?

    在使用自定义tabbar时,你可能会需要获取tabbar的高度,但是按照网上的方法却得不到正确的结果,这让你十分头疼。那么该怎么办呢?小编为大家整理了以下几个方法,希望能够帮到大家。 1️⃣ 使用wx.getSystemInfoSync()方法获取系统信息,然后通过计算得出tabbar的高度。 示例

    2024年02月11日
    浏览(50)
  • CompletableFuture解决多线程返回结果问题

    在Java中CompletableFuture用于异步编程,异步编程是编写非阻塞的代码,运行的任务在一个单独的线程,与主线程隔离,并且会通知主线程它的进度,成功或者失败。 在这种方式中,主线程不会被阻塞,不需要一直等到子线程完成。主线程可以并行的执行其他任务。 使用这种并

    2024年02月16日
    浏览(37)
  • java多线程怎么同步返回结果

    在 Java 多线程中,如果需要等待线程执行完成并返回结果,可以使用 Java 的线程同步机制来实现。以下是一些常用的方式: 使用 join() 方法:可以使用线程的 join() 方法来等待线程执行完成。在主线程中调用 join() 方法,会阻塞主线程,直到该线程执行完成。在被等待的线程执

    2024年02月14日
    浏览(22)
  • 【面试问题】事务中执行了异步任务分发数据,由于事务未提交,导致异步任务无法执行

    客户数据分发CRMS系统的时候异常,分发任务强依赖于事务内有没有提交,异常由事务未及时提交导致异步任务无法及时查到数据,现将异步任务调整为事务提交后处理 添加事务同步管理器,声明异步是在事务提交后执行

    2024年02月13日
    浏览(28)
  • 循环异步调取接口使用数组promiseList保存,Promise.all(promiseList)获取不到数组内容,then()返回空数组

    在使用 vue + vant@2.13.2 技术栈的项目中,因为上传文件的接口是单文件上传,当使用批量上传时,只能循环调取接口;然后有校验内容:需要所有文件上传成功后才能保存,在文件上传不成功时点击保存按钮,则提示信息: \\\"文件上传未成功!\\\" 。 我使用 for 循环调取接口,然

    2024年01月18日
    浏览(29)
  • 配置 mybatis 打印出执行的 sql 及返回的结果集

    在开发过程中, 经常会遇到想要看到应用所执行的 sql 这样的需求. 比如你写了一个查询的功能, 但查询出来的结果与你预期的不符合, 你想搞清楚到底哪里出了问题, 你自然需要看看所执行的 sql 语句, 必要的话甚至还要亲自拷贝到数据库里去查查. 自然, 这就要求应用要能把执

    2024年02月07日
    浏览(35)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包