并发编程九-Callable/Future和CompletableFuture介绍

最新推荐文章于 2024-05-11 19:00:49 发布
最新推荐文章于 2024-05-11 19:00:49 发布
阅读量1.3k 收藏 5
点赞数
分类专栏： 并发编程 文章标签： java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_32689899/article/details/106892788
版权

一、概述

在业务需求中，很多时候异步执行某个任务之后是需要获取到执行结果的，但是使用继承Thread类和实现Runnable接口的方法来异步执行任务时，想要得到执行结果往往都不是很方便。那么除了这两种方式可以用来执行异步任务之外，还有一种方式可是实现，并且还可以简单的就获取到异步执行的结果，那就是Callable。

在使用Callable的同时一般都会使用Future来配合获取执行结果。

二、使用

现在有一个简单的业务需求：根据条件去多个服务器上获取资源，然后把资源放到一起，比如说根据图片编号去10台服务器上取出与该编号相关的10张图片

1，使用Runnable来实现

实现：创建10个线程，每个线程去一台服务器上获取图片资源，然后把获取到的结果方法一个线程安全的集合中，等待10个线程执行完成，就可以从这个集合中取出想要的结果

代码：

import java.util.*;

/**
 * 使用runnable异步获取多个资源
 */
public class SearchImageDemo1 {
    public static void main(String[] args) throws InterruptedException {
        long start = System.currentTimeMillis();
        String key = "image";
        int searchCount = 10;// 10个资源存放点
        // 用于存放线程
        List<Thread> threadList = new ArrayList<>();
        // 用于存放查询结果
        List<String> resList = Collections.synchronizedList(new ArrayList<>());
        for (int i = 0; i < searchCount; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        // 查询并返回结果，把结果放入集合中
                        String data = getData(key);
                        resList.add(data);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            },"Thread-"+i);
            thread.start();
            threadList.add(thread);
        }
        // 等待10个线程执行结束后程序才继续执行
        for (Thread thread : threadList) {
            thread.join();
        }
        long end = System.currentTimeMillis();
        System.out.println("总耗时："+(end-start)+"ms");
        System.out.println(resList.toString());// 输出查询结果
    }

    // 获取资源的方法
    private static String getData(String str) throws InterruptedException {
        long l = new Random().nextInt(3000);
        Thread.sleep(l);// 模拟http请求耗时操作
        System.out.println(Thread.currentThread().getName()+"耗时："+l);
        return str+":"+ UUID.randomUUID().toString();
    }
}

2，使用Callable和FutureTask实现

实现：FutureTask是属于Future的一个实现类，同时它来实现了Runnable接口，所以可以把FutureTask放到Thread中执行。

代码：

import java.util.*;
import java.util.concurrent.*;

/**
 * 使用Callable和FutureTask实现
 */
public class SearchImageDemo2 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        long start = System.currentTimeMillis();
        String key = "image";
        int searchCount = 10;// 10个资源存放点
        // 用于存放Future
        List<FutureTask> futureTaskList = new ArrayList<>();
        // 用于存放查询结果
        List<String> resList = Collections.synchronizedList(new ArrayList<>());
        for (int i = 0; i < searchCount; i++) {
            FutureTask<String> futureTask = new FutureTask<>(new Callable<String>() {
                @Override
                public String call() throws Exception {
                    return getData(key);
                }
            });
            futureTaskList.add(futureTask);
            Thread thread = new Thread(futureTask,"Thread-"+i);
            thread.start();
        }
        // 收集10个线程执行的结果，并把结果放入到集合中
        for (FutureTask<String> futureTask : futureTaskList) {
            String res = futureTask.get();
            resList.add(res);
        }
        long end = System.currentTimeMillis();
        System.out.println("总耗时："+(end-start)+"ms");
        System.out.println(resList.toString());// 输出查询结果
    }

    // 获取资源的方法
    private static String getData(String str) throws InterruptedException {
        long l = new Random().nextInt(3000);
        Thread.sleep(l);
        System.out.println(Thread.currentThread().getName()+"耗时："+l);
        return str+":"+ UUID.randomUUID().toString();
    }
}

3，使用线程池、Callable和Future实现

实现：使用线程池的submit（）方法，该方法接收一个Callable实现类，把任务交由线程池来执行，然后从Future中获取执行结果。

代码：

import java.util.*;
import java.util.concurrent.*;

/**
 * 使用线程池、Callable和Future实现
 */
public class SearchImageDemo3 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        long start = System.currentTimeMillis();
        String key = "image";
        int searchCount = 10;// 10个资源存放点
        // 用于存放线程
        List<Future> futureTaskList = new ArrayList<>();
        // 用于存放查询结果
        List<String> resList = Collections.synchronizedList(new ArrayList<>());
        for (int i = 0; i < searchCount; i++) {
            Future<String> future = executorService.submit(new Callable<String>() {
                @Override
                public String call() throws Exception {
                    return getData(key);
                }
            });
            futureTaskList.add(future);
        }
        // 收集10个线程执行的结果，并把结果放入到集合中
        for (Future<String> future : futureTaskList) {
            String res = future.get();
            resList.add(res);
        }
        long end = System.currentTimeMillis();
        System.out.println("总耗时："+(end-start)+"ms");
        System.out.println(resList.toString());// 输出查询结果
        executorService.shutdown();// 关闭线程池
    }

    // 获取资源的方法
    private static String getData(String str) throws InterruptedException {
        long l = new Random().nextInt(3000);
        Thread.sleep(l);
        System.out.println(Thread.currentThread().getName()+"耗时："+l);
        return str+":"+ UUID.randomUUID().toString();
    }
}

三、Future的方法

get()：会阻塞线程，直到任务执行完毕

get(long timeout,TimeUnit unit)：可以设置等待超时时间，如果在指定时间内任务还没有返回结果，那么取消阻塞等待。

cancel(boolean mayInterruptIfRunning)：方法可以用来停止一个任务，如果任务可以停止（通过mayInterruptIfRunning来进行判断），则可以返回true,如果任务已经完成或者已经停止，或者这个任务无法停止，则会返回false.

isDone()：判断当前方法是否完成

isCancel()：判断当前方法是否取消

四、使用CompletableFuture

在jdk1.8中，提供了一个异步处理任务的工具

1，使用CompletableFuture实现上面的需求

import java.util.*;
import java.util.concurrent.*;

/**
 * 使用CompletableFuture实现
 */
public class SearchImageDemo4 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        long start = System.currentTimeMillis();
        String key = "image";
        int searchCount = 10;// 10个资源存放点
        // 用于执行结果
        CompletableFuture<String>[] futures = new CompletableFuture[searchCount];
        // 用于存放查询结果
        List<String> resList = Collections.synchronizedList(new ArrayList<>());
        // 启动10个任务异步执行
        for (int i=0;i<searchCount;i++) {
            futures[i] = CompletableFuture.supplyAsync(() -> {
                try {
                    return getData(key);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return null;
            });
        }
        // 获取这些执行结果
//        Stream.of(futures).forEach((f)->{f.whenComplete((v,e)->{resList.add(v);}).join();});
        for (CompletableFuture<String> future : futures) {
            future.whenComplete((v,e)->{
                resList.add(v);
            }).join();
        }
        long end = System.currentTimeMillis();
        System.out.println("总耗时："+(end-start)+"ms");
        System.out.println(resList.toString());// 输出查询结果
    }

    // 获取资源的方法
    private static String getData(String str) throws InterruptedException {
        long l = new Random().nextInt(3000);
        Thread.sleep(l);
        System.out.println(Thread.currentThread().getName()+"耗时："+l);
        return str+":"+ UUID.randomUUID().toString();
    }
}

2，CompletableFuture介绍

2.1 创建一个CompletableFuture异步操作对象

有两个方法：

runAsync():接收一个Runnable对象，执行之后没有返回值。重载方法可以指定线程池，如果不传则默认使用ForkJoinPool.commonPool()作为线程池。

supplyAsync()：接受Supplier对象，执行之后有返回值。重载方法可以指定线程池，如果不传则默认使用ForkJoinPool.commonPool()作为线程池。

2.2 获取执行结果

2.2.1 同步获取结果

使用get()或者join()方法获取结果

2.2.2 任务完成之后处理结果

whenComplete():使用当前执行任务的线程处理结果

whenCompleteAsync():使用线程池中的线程处理结果

exceptionally():返回一个新的CompletableFuture，它在CompletableFuture完成时完成，当它异常完成时，给定的异常函数会触发;如果这个CompletableFuture正常完成，那么返回的CompletableFuture也以相同的值正常完成。

handle()：在任务执行完成后对结果进行处理，如果执行过程中发生异常，还可以对异常进行捕获并处理。

 

 

ns_salulu
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java并发编程的艺术源码
11-17
《Java并发编程的艺术》是一本深入探讨Java平台上的并发编程技术的专业书籍，其源码提供了丰富的实例和示例，帮助读者理解并发编程的核心概念和最佳实践。在Java中，并发编程是开发高效、可扩展应用的关键技能，尤其...
java源码之并发编程
11-17
Java并发编程是一个深度和广度都很大的主题，涉及到很多底层细节和设计模式。理解和掌握这些知识点，能够帮助开发者编写出高效、稳定的并发程序。在实践中，结合Java源码学习，可以更深入地理解这些机制的工作原理。
【并发编程学习篇】Future&CompletableFuture的使用与原理剖析
一个勤勤恳恳的程序猿
03-17 5688
当需要批量提交异步任务的时候建议你使用CompletionServiceCompletionService将线程池Executor和阻塞队列BlockingQueue的功能融合在了一起，能够让批量异步任务的管理更简单。CompletionService能够让异步任务的执行结果「有序化」先执行完的先进入阻塞队列，利用这个特性，你可以轻松实现后续处理的有序性，避免无谓的等待，同时还可以快速实现诸如Forking Cluster这样的需求。线程池隔离。
Java多线程 - 利用Callable或CompletableFuture实现多线程异步任务执行
你今天真好看呀
02-20 2567
对于Calleble来说，Future和FutureTask均可以用来获取任务执行结果，不过Future是个接口，FutureTask是Future的具体实现，而且FutureTask还间接实现了Runnable接口，也就是说FutureTask可以作为Runnable任务提交给线程池。如果异步任务没有执行完成，异步结果获取线程（调用线程）会一直被阻塞，一直阻塞到异步任务执行完成，其异步结果返回给调用线程。(2) RunnableFuture通过继承Future接口，从而保证了可以获取未来的异步执行结果。
深入理解Java并发：Future与CompletableFuture详解
TFHoney的博客
05-11 1578
在多线程编程中，异步计算是一种常见的需求。其中Future和CompletableFuture是处理异步计算结果的两大核心接口。本文将详细介绍Future和CompletableFuture的概念、使用方法以及它们之间的区别。Future为Java引入了异步计算的概念，而CompletableFuture在此基础上进行了全面升级，提供了更为强大和灵活的异步编程工具集。在进行高并发、高性能应用开发时，合理运用CompletableFuture能够显著提升系统的响应速度和资源利用率。
Runnable、Callable、Future、CompletableFuture的区别
xueqingna的博客
04-13 737
多线程相关
提升--15---线程池--01---基本概念、Callable、Future、CompletableFuture
时光里的博客
09-30 353
文章目录线程池---基本概念多线程--08--线程池1. Executor--ExecutorService--ThreadPoolExecutorExecutorExecutorServicesubmit()方法==submit提交任务==: 把任务扔给这个线程池，什么时候运行由这个线程池来决定，相当于是异步的，Callable---接口流程:案例1：Callable的实现类案例2: Callable实现类结合线程池如何理解实现Callable接口的方式比实现Runnable接口创建多线程方式强大？Fut
转载:Java中的Runnable、Callable、Future、FutureTask的区别和CompletionService的使用场景
从入门到放弃的博客
04-23 297
https://blog.csdn.net/jdsjlzx/article/details/52912701
java并发编程-从入门到精通
02-02
Java提供了丰富的并发工具和API来支持并发编程，如线程（Thread）、Executor框架、Future、Callable和Runnable接口等。 在Java中，线程的创建和管理是通过继承Thread类或实现Runnable接口来完成的。理解如何正确地...
java虚拟机并发编程.pdf
06-14
5. **并发工具类**：ExecutorService、Future和Callable接口是Java并发编程的重要组成部分，它们提供了线程池管理和异步任务执行的能力。 6. **并发模式**：书中会讨论一些经典的并发模式，如生产者消费者模型、...
Java编程之高并发核心源码
11-17
首先，我们要了解Java并发编程的基础，即线程。Java提供了Thread类和Runnable接口来创建和管理线程。通过实现Runnable接口或继承Thread类，可以定义线程执行的逻辑。然而，线程的直接创建和管理可能会导致资源浪费，...
JAVA学习笔记（三）-并发编程 Callable Future CompleableFuture
chenlin597898889的博客
06-16 3806
Runnable 是一个接口，里面只声明了一个方法run();返回值为void所以无法拿到执行完的结果。只能通过共享变量或者线程通信来搞定。//函数式接口注解 @FunctionalInterface public interface Runnable { public abstract void run(); }Callable同样也只是一个接口，只声明了一个方法call(),可以看出来
并发之Runnable、Callable、FutureTask及CompletableFuture原理分析
公号：黎杜编程
07-17 310
引言关于Runnable、Callable接口大家可能在最开始学习Java多线程编程时，都曾学习过一个概念：在Java中创建多线程的方式有三种：继承Thread类、实现Runnable接口以及实现Callable接口。但是实则不然，真正创建多线程的方式只有一种：继承Thread类，因为只有new Thread().start()这种方式才能真正的映射一条OS的内核线程执行，而关于实现Runnabl...
Future、Callable and CompletableFuture
雨后是冰雹
08-01 394
一、Callable二、FutureFuture 的主要方法 一、Callable Callable 接口类似于 Runnable，但是 Runnable 不会返回结果，并且无法抛出返回结果的异常，而 Callable 功能更强大一些，被线程执行后，可以返回值，这个返回值可以被 Future 拿到，也就是说，Future 可以通过 get()/get(long timeout, TimeUnit unit) 拿到异步执行任务的返回值. @FunctionalInterface public interfa.
《尚硅谷高级技术之JUC高并发编程》学习笔记12—— CompletableFuture
weixin_43301424的博客
11-21 687
文章目录completableFuture 简介Future 与 CompletableFutureCompletableFuture 入门使用 CompletableFuture没有返回值的异步任务有返回值的异步任务线程依赖消费处理结果异常处理结果合并总结 completableFuture 简介 CompletableFuture 在 Java 里面被用于异步编程，异步通常意味着非阻塞，可以使得我们的任务单独运行在与主线程分离的其他线程中，并且通过回调可以在主线程中得到异步任务的执行状态，是否完成，和
多线程——(Callable)(Future)(CompletableFuture)
hwp_ing的博客
09-28 434
当几个异步任务相互关联时就要使用到异步任务编排。当几个异步任务相互关联时就要使用到异步任务编排。除了以上三种还可以通过线程池开启。
线程池+ Callable +CompletableFuture 的基本使用
蜡笔小明的博客
03-18 1575
线程池的作用 1、减少线程创建与切换的开销 在没有使用线程池的时候，来了一个任务，就创建一个线程，我们知道系统创建和销毁工作线程的开销很大，而且频繁的创建线程也就意味着需要进行频繁的线程切换，这都是一笔很大的开销。 2、控制线程的数量 使用线程池我们可以有效地控制线程的数量，当系统中存在大量并发线程时，会导致系统性能剧烈下降。 3、循环利用有限的线程 线程池中会预先...
异步编程：CompletableFuture详解使用
勿扰博客
12-06 752
一、创建异步任务 二、异步回调 三、组合处理 CompletableFuture实现了CompletionStage接口和Future接口，前者是对后者的一个扩展，增加了异步回调、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。
Future，FutureTask，CompletableFuture
Tezuka
07-25 1171
Java中线程的实现方式一般有实现Runable接口，实现Callable接口，继承Thread类三种。而Runable和Thread的run方法都是void，也就是没有返回值，所以这种情况下获取线程的返回值就要使用线程间通信的手段，一般比较麻烦，基于Future有两种方式可以获取线程的返回值，比较方便。 使用Future+Callable的形式，用Future接受Callable任务的返回值 ...
CompletableFuture和Callable、Future的区别是什么？
最新发布
07-09
`CompletableFuture` 是 Java 8 引入的一个异步编程工具，它提供了一种更简洁的方式来处理基于回调的并发任务。相比之下，`Callable` 和 `Future` 的区别在于： 1. **Callable vs Future**: `Callable` 是一个泛型接口，用于执行计算并返回结果，而 `Future` 只是一个接口，代表了某个异步操作的结果在未来某时可用。你可以将 `Callable` 结果转化为 `Future`，但反过来则不行。 2. **结果获取**：`Future` 提供了 `get()` 或 `isDone()` 等方法来检查任务是否完成并获取结果，但如果没有异常抛出，它会阻塞直到计算完成。`CompletableFuture` 则提供非阻塞的获取方式，如 `thenApply()` 和 `thenAccept()`，可以立即继续后续操作，而不是等待任务完成。 3. **错误处理**：`Future` 的 `get()` 方法如果发生异常会被隐式地封装为运行时异常。而 `CompletableFuture` 允许对失败情况有更精细的控制，例如通过 `exceptionally()` 方法处理异常。 4. **链式调用**：`CompletableFuture` 支持链式调用，允许你在一行代码中表达复杂的异步操作流程，这使得代码更加清晰和易于维护。 5. **流式API支持**：`CompletableFuture` 能很好地与其他 Stream API 集成，方便地构建并行数据处理管道。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值