1. Toy模板网首页
  2. > Toy博客

【Java 8 新特性】Java CompletableFuture supplyAsync()详解

9月前 作者：Chen陈c 分类：Toy博客 阅读(52) 违法举报

这篇具有很好参考价值的文章主要介绍了【Java 8 新特性】Java CompletableFuture supplyAsync()详解。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

【Java 8 新特性】Java CompletableFuture supplyAsync()

supplyAsync()是Java 8引入的CompletableFuture静态方法。

1.supplyAsync(Supplier supplier)

supplyAsync()默认完成在ForkJoinPool.commonPool()或指定Executor中异步执行的任务。

方法声明：supplyAsync(Supplier supplier)

需要将Supplier作为任务传递给supplyAsync()方法。

默认情况下，此任务将在ForkJoinPool.commonPool()中异步完成执行，最后supplyAsync()将返回新的CompletableFuture,其值是通过调用给定的Supplier所获得的值。

代码示例：

CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> "Hello CompletableFuture");
System.out.println(completableFuture.get());

2.supplyAsync(Supplier supplier, Executor executor)

方法声明：supplyAsync(Supplier supplier, Executor executor)

需要将Supplier作为任务传递给supplyAsync()方法，并且指定Executor，任务将在给定的Executor中异步完成。最后supplyAsyncl()将返回具有通过调用给定Supplier所获得的值的新CompletableFuture。

示例代码：

ExecutorService executorService = Executors.newSingleThreadExecutor();
CompletableFuture<String> cf = CompletableFuture.supplyAsync(
		()-> "Hello CompletableFuture!", 
		executorService
	 );
System.out.println(cf.get());

3.使用thenApply()

thenApply()通过传递阶段结果来执行一个函数。当supplyAsync和thenApply()一起使用，thenApply()将从supplyAsync()获得的参数传递来执行给定的函数。

thenApply 接收一个函数作为参数，使用该函数处理上一个CompletableFuture 调用的结果，并返回一个具有处理结果的Future对象。

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class SupplyAsyncExample {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		CompletableFuture<String> cf = CompletableFuture.supplyAsync(()-> getDataById(1))
				.thenApply(data -> sendData(data));
		cf.get();
	}
	private static String getDataById(int id) {
		System.out.println("getDataById: "+ Thread.currentThread().getName());
		return "Data:"+ id;
	}
	private static String sendData(String data) {
		System.out.println("sendData: "+ Thread.currentThread().getName());
		System.out.println(data);
		return data;
	}	
}

输出结果：

getDataById: ForkJoinPool.commonPool-worker-1
sendData: main
Data:1

主线程开始执行代码，当代码到达supplyAsync()时，supplyAsync()从ForkJoinPool.commonPool()获取新线程以异步执行其功能。

thenApply()将由主线程或supplyAsync()使用的线程执行。

如果supplyAsync()的Supplier花费的时间更长，则thenApply()将由supplyAsync()所使用的线程执行，因此主线程将不会被阻塞。

代码示例：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class SupplyAsyncExample {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		CompletableFuture<String> cf = CompletableFuture.supplyAsync(()-> getDataById(1))
				.thenApply(data -> sendData(data));
		cf.get();
	}
    
private static String getDataById(int id) {
  System.out.println("getDataById: "+ Thread.currentThread().getName());
  try {
	Thread.sleep(1000);
  } catch (InterruptedException e) {
	e.printStackTrace();
  }		
  return "Data:"+ id;
} 
    private static String sendData(String data) {
		System.out.println("sendData: "+ Thread.currentThread().getName());
		System.out.println(data);
		return data;
	}	
}

输出：

getDataById: ForkJoinPool.commonPool-worker-1
sendData: ForkJoinPool.commonPool-worker-1
Data:1

4.自定义Executor

将Executor作为入参传递给supplyAsync()。

传递给supplyAsync()的Supplier将由上面传入的Executor执行，而不是由ForkJoinPool.commonPool()执行。

package com.example.supplyAsyncExample;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SupplyAsyncExample02 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(
                () -> getById(1),
                executorService
        )
                .thenApply(data -> sendData(data));
        completableFuture.get();
        executorService.shutdown();
    }

    private static String getById(int id){
        System.out.println("getById：" + Thread.currentThread().getName());
        return "Data：" + id;
    }

    private static String sendData(String data){
        System.out.println("sendData：" + Thread.currentThread().getName());
        System.out.println(data);
        return data;
    }
}

输出：

getById：pool-1-thread-1
sendData：pool-1-thread-1
Data：1
也有可能是：
getById：pool-1-thread-1
sendData：main
Data：1

5.使用whenComplete()

whenComplete()方法创建supplyAsync()。

完成指定操作之后，wenComplete()返回具有相同结构或异常的新CompletionStage

当CompletableFuture的任务不论是正常完成还是出现异常它都会调用whenComplete这回调函数。

正常完成：whenComplete返回结果和上级任务一致，异常为null；

出现异常：whenComplete返回结果为null，异常为上级任务的异常；

即调用get()时，正常完成时就获取到结果，出现异常时就会抛出异常，需要你处理该异常。

示例代码：

package com.example.supplyAsyncExample;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SupplyAsyncExample03 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(
                () -> getById(1)
        )
                .whenComplete((data, exception) -> {
                    consumeData(data);
                    if (exception != null){
                        System.out.println(exception);
                    }
                });
        completableFuture.get();
    }

    private static String getById(int id){
        System.out.println("getById：" + Thread.currentThread().getName());
        return "Data：" + id;
    }

    private static String consumeData(String data){
        System.out.println("sendData：" + Thread.currentThread().getName());
        System.out.println(data);
        return data;
    }
}

6.stream流

package com.example.supplyAsyncExample;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class SupplyAsyncExample04 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        List<Integer> list = Arrays.asList(1, 2, 3);

        long count = list.stream().map(n -> CompletableFuture.supplyAsync(() -> getById(n)))
                .map(completableFuture -> completableFuture.thenApply(data -> sendData(data)))
                .map(t -> t.join()).count();
        System.out.println("count: " + count);
    }

    private static String getById(int id) {
        System.out.println("getById：" + Thread.currentThread().getName());
        return "Data：" + id;
    }

    private static String sendData(String data) {
        System.out.println("sendData：" + Thread.currentThread().getName());
        System.out.println(data);
        return data;
    }
}

输出结果：文章来源地址https://www.toymoban.com/news/detail-836356.html

getById：ForkJoinPool.commonPool-worker-1
sendData：ForkJoinPool.commonPool-worker-1
Data：1
getById：ForkJoinPool.commonPool-worker-1
sendData：ForkJoinPool.commonPool-worker-1
Data：2
getById：ForkJoinPool.commonPool-worker-1
sendData：main
Data：3
count: 3

到了这里，关于【Java 8 新特性】Java CompletableFuture supplyAsync()详解的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

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

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • CompletableFuture使用详解（全网看这一篇就行）

    CompletableFuture使用详解（全网看这一篇就行）

    CompletableFuture是jdk8的新特性。CompletableFuture实现了CompletionStage接口和Future接口，前者是对后者的一个扩展，增加了异步会点、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。 1. supplyAsync supplyAsync是创建带有返回值的异步任务。它有如下两

    2024年02月03日
    浏览(48)

  • Java组合式异步编程CompletableFuture

    CompletableFuture是Java 8中引入的一个功能强大的Future实现类，它的字面翻译是“可完成的Future”。 CompletableFuture对并发编程进行了增强，可以方便地将多个有一定依赖关系的异步任务以流水线的方式组合在一起，大大简化多异步任务的开发。 CompletableFuture实现了两个接口，一个

    2024年04月09日
    浏览(36)
  • CompletableFuture：Java中的异步编程利器

    CompletableFuture：Java中的异步编程利器

    前言： 在秋招的面试中，面试官问了很多关于异步编程相关的知识点，朋友最近也和我聊到了这个话题，因此今天咱们来讨论讨论这个知识点！ 随着现代软件系统的日益复杂，对于非阻塞性和响应性的需求也在不断增加。Java为我们提供了多种工具和技术来满足这些需求，其

    2024年02月04日
    浏览(36)
  • Java的CompletableFuture，Java的多线程开发

    Java的CompletableFuture，Java的多线程开发

    如下图： 以后用到再加 get() 和 join() 方法区别？ 都可以阻塞线程 —— 等所有任务都执行完了再执行后续代码。 anyOf() 和 allOf() 的区别？ 无返回值 推荐： 开启多线程——无返回值的——阻塞 ：test06 有返回值 推荐：开启多线程——有返回值的，返回一个新的List——阻塞—

    2024年02月06日
    浏览(45)

  • 「Java」《深入解析Java多线程编程利器：CompletableFuture》

    多线程编程是指在一个程序中同时执行多个线程来提高系统的并发性和响应性。在现代计算机系统中，多线程编程已经成为开发者日常工作的一部分。以下是对多线程编程需求和挑战的介绍： 需求： 提高系统的性能：通过同时执行多个线程，可以利用多核处理器的优势，实

    2024年02月11日
    浏览(49)

  • 从 Future 到 CompletableFuture：简化 Java 中的异步编程

    在并发编程中，我们经常需要处理多线程的任务，这些任务往往具有依赖性，异步性，且需要在所有任务完成后获取结果。Java 8 引入了 CompletableFuture 类，它带来了一种新的编程模式，让我们能够以函数式编程的方式处理并发任务，显著提升了代码的可读性和简洁性。 在这篇

    2024年02月11日
    浏览(34)
  • CompletableFuture异步编程事务及多数据源配置详解(含gitee源码)

    CompletableFuture异步编程事务及多数据源配置详解(含gitee源码)

    仓库地址: buxingzhe: 一个多数据源和多线程事务练习项目 小伙伴们在日常编码中经常为了提高程序运行效率采用多线程编程，在不涉及事务的情况下，使用dou.lea大神提供的CompletableFuture异步编程利器，它提供了许多优雅的api，我们可以很方便的进行异步多线程编程，速度杠杠

    2024年01月22日
    浏览(42)

  • CompletableFuture与线程池：Java 8中的高效异步编程搭配

    摘要：在Java 8中，CompletableFuture和线程池的结合使用为程序员提供了一种高效、灵活的异步编程解决方案。本文将深入探讨CompletableFuture和线程池结合使用的优势、原理及实际应用案例，帮助读者更好地理解并掌握这一技术。 随着多核处理器的普及，应用程序的性能和响应能

    2024年02月07日
    浏览(62)

  • 并发编程 | 从Future到CompletableFuture - 简化 Java 中的异步编程

    在并发编程中，我们经常需要处理多线程的任务，这些任务往往具有依赖性，异步性，且需要在所有任务完成后获取结果。Java 8 引入了 CompletableFuture 类，它带来了一种新的编程模式，让我们能够以函数式编程的方式处理并发任务，显著提升了代码的可读性和简洁性。 在这篇

    2024年02月13日
    浏览(47)

  • Java学习笔记-day06-响应式编程Reactor与Callback、CompletableFuture三种形式异步编码对比

    Reactor 是一个基于Reactive Streams规范的响应式编程框架。它提供了一组用于构建异步、事件驱动、响应式应用程序的工具和库。Reactor 的核心是 Flux （表示一个包含零到多个元素的异步序列）和 Mono 表示一个包含零或一个元素的异步序列）。 Reactor 通过提供响应式的操作符，如

    2024年02月03日
    浏览(41)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包