`

CompletableFuture - 常用API(上)

 
阅读更多

原创转载请注明出处:http://agilestyle.iteye.com/blog/2427512

 

先看一个简单的例子

package org.fool.java8.completable;

import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.stream.Stream;

import static java.util.stream.Collectors.toList;

public class CompletableFutureTest4 {

    private final static Random RANDOM = new Random(System.currentTimeMillis());

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(2);

//        CompletableFuture.supplyAsync(CompletableFutureTest4::get, executorService)
//                .thenApply(CompletableFutureTest4::multiply)
//                .whenComplete((v, t) -> {
//            Optional.ofNullable(v).ifPresent(System.out::println);
//            Optional.ofNullable(t).ifPresent(Throwable::printStackTrace);
//        });

        System.out.println("===========main start no block============");

        List<Integer> productionIds = Arrays.asList(1, 2, 3, 4, 5);
//        Stream<CompletableFuture<Double>> completableFutureStream =
//                productionIds.stream().map(i -> CompletableFuture.supplyAsync(() -> queryProduction(i), executorService));
//
//        Stream<CompletableFuture<Double>> multiplyFutures = completableFutureStream.map(future -> future.thenApply(CompletableFutureTest4::multiply));
//
//        List<Double> result = multiplyFutures.map(CompletableFuture::join).collect(toList());

        List<Double> result = productionIds.stream()
                .map(i -> CompletableFuture.supplyAsync(() -> queryProduction(i), executorService))
                .map(future -> future.thenApply(CompletableFutureTest4::multiply))
                .map(future -> future.thenApply(CompletableFutureTest4::subtract))
                .map(CompletableFuture::join).collect(toList());

        System.out.println(result);

        System.out.println("=========main end no block==========");
    }

    private static double get() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        double result = RANDOM.nextDouble();
        System.out.println(Thread.currentThread().getName() + ":" + result);
        return result;
    }

    private static double queryProduction(int i) {
        return CompletableFutureTest4.get();
    }

    private static double multiply(double value) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        return value * 10d;
    }

    private static double subtract(double value) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        return value - 1;
    }
}

Note:  将列表中的数字,统一放到一个线程池中处理,  先get,接着multiply,然后substract,最后join


Console  Output


 

thenApply

private static void testThenApply() {
	CompletableFuture.supplyAsync(() -> 1)
			.thenApply(i -> Integer.sum(i, 10))
			.whenComplete((v, t) -> System.out.println(v));
}

 Console  Output



handle

private static void testHandle() {
	CompletableFuture.supplyAsync(() -> 1)
			.handle((v, t)-> Integer.sum(v, 10))
			.whenComplete((v, t) -> System.out.println(v));
}

 Console Output


 

thenRun

private static void testThenRun() {
	CompletableFuture.supplyAsync(() -> 1)
			.handle((v, t)-> Integer.sum(v, 10))
			.whenComplete((v, t) -> System.out.println(v))
			.thenRun(() -> System.out.println("action ended..."));
}

Console Output


 

thenAccept

private static void testThenAccept() {
	CompletableFuture.supplyAsync(() -> 1)
			.thenApply(i -> Integer.sum(i, 10))
			.thenAccept(System.out::println);
}

Console Output


 

thenCompose

private static void testThenCompose() {
	CompletableFuture.supplyAsync(() -> 1)
			.thenCompose(i -> CompletableFuture.supplyAsync(() -> 10 * i))
			.thenAccept(System.out::println);
}

Console Output


 

thenCombine

private static void testThenCombine() {
	CompletableFuture.supplyAsync(() -> 1)
			.thenCombine(CompletableFuture.supplyAsync(() -> 2), (r1, r2) -> r1 + r2)
			.thenAccept(System.out::println);
}

Console Output


 

thenAcceptBoth

private static void testThenAcceptBoth() {
	CompletableFuture.supplyAsync(() -> 1)
			.thenAcceptBoth(CompletableFuture.supplyAsync(() -> 2), (r1, r2) -> {
				System.out.println(r1);
				System.out.println(r2);
				System.out.println(r1 + r2);
			});
}

Console Output


 

 

  • 大小: 19.2 KB
  • 大小: 33.2 KB
  • 大小: 9.4 KB
  • 大小: 9.3 KB
  • 大小: 11 KB
  • 大小: 9.7 KB
  • 大小: 9.8 KB
  • 大小: 9.4 KB
  • 大小: 12 KB
分享到:
评论

相关推荐

    jdk8-api文档

    - 常用方法包括 `filter()`、`map()`、`reduce()`、`collect()` 等,可以方便地进行数据过滤、转换和聚合操作。 - 并行流(Parallel Streams)利用多核处理器优势,实现高效的数据处理。 3. **日期和时间 API...

    gitlab-api-service-provider-源码.rar

    理解API的基本结构和常用端点是使用GitLab API Service Provider的前提。 2. **OAuth2认证**: 要与GitLab API交互,通常需要进行OAuth2认证。GitLab API Service Provider会处理授权流程,获取访问令牌,并在后续...

    java常用api文档前端相关

    总的来说,Java API在前端开发中的应用主要体现在后端服务的构建上,包括数据处理、通信协议、安全机制、性能优化等方面。熟悉这些Java API的前端开发者能够更好地理解和配合后端工作,提高整体项目的开发效率和质量...

    third-party-api-sim

    "third-party-api-sim"这个项目可能是一个模拟第三方API的工具或者一个教学示例,它专注于帮助开发者理解和学习如何有效地集成和使用第三方API。这个项目标签为"Java",意味着它是用Java编程语言实现的。 首先,让...

    Java 8 API Docs

    - 常用方法包括`filter()`, `map()`, `reduce()`, `collect()`等,支持并行和串行操作。 4. **Optional类**: - `Optional&lt;T&gt;`用于表示可能为`null`的值,防止空指针异常。 - 它提供了`isPresent()`, `get()`, `...

    java调用api的方法

    Java 8引入了CompletableFuture,配合ExecutorService,可以轻松实现非阻塞调用。第三方库如Retrofit也提供了异步调用的支持。 7. **测试API调用**:单元测试和集成测试对于API调用的代码至关重要。JUnit和Mockito...

    java8官方api帮助文档

    常用的操作有map(映射),filter(过滤),reduce(聚合)等。通过Stream API,开发者可以编写出简洁且高效的代码来处理大量数据。 4. **日期与时间API**: 在Java 8之前,日期和时间处理相对复杂,Java 8引入了...

    java1.8api中文版

    7. **并发API增强**:Java 1.8进一步优化了并发处理,如`ForkJoinPool`和`CompletableFuture`,提供了并行计算的新方式,使得异步编程更为简单。 8. ** Nashorn JavaScript引擎**:Java 8引入了一个新的脚本引擎...

    【API】jdk api 1.8.rar

    例如,`java.util.ArrayList`和`java.util.HashMap`是开发中最常用的集合类,`java.io`包提供了输入输出操作,`java.nio`包则引入了非阻塞I/O。 2. **泛型**:Java 1.5引入的泛型提高了代码的类型安全性和可读性,...

    desafio-bempromotora:API pesquisa com客户端

    1. **网络请求库**:在Java中,常用的网络请求库有HttpURLConnection(Java标准库)、Apache HttpClient、OkHttp以及Spring的RestTemplate。开发者可能会使用这些库来构建向服务器发送请求的逻辑。 2. **JSON解析**...

    smart-doc是一款同时支持JAVA REST API和Apache Dubbo RPC接口文档生成的工具,.rar

    smart-doc是一款同时支持JAVA REST API和Apache Dubbo RPC接口文档生成的工具,smart-doc在业内率先提出基于JAVA泛型定义推导的理念,完全基于接口源码来分析生成接口文档,不采用任何注解侵入到业务代码中。...

    jdk api1.8中文版本

    本篇将围绕JDK API 1.8中文版本,详细解析其关键特性、重要更新以及常用类库的使用。 首先,JDK 1.8是Java发展历程中的一个重要里程碑,它引入了许多创新性特性和功能,例如Lambda表达式、函数式接口、Stream API、...

    JDK 1.8 API 应用程序编程接口

    - `CompletableFuture`:提供了异步编程的支持,允许组合多个异步任务。 以上只是JDK 1.8 API中的一部分关键知识点,实际使用中,开发者还需要深入理解和掌握异常处理、I/O流、网络编程、反射、注解等更多内容。...

    jdk_api_1.8.zip

    例如,`java.util`包中的ArrayList和HashMap是常用的集合类,`java.io`包提供了处理文件和流的工具。 2. **Lambda表达式** JDK 1.8引入了lambda表达式,这是函数式编程的重要特性,简化了匿名内部类的使用,使得...

    115-springboot-demo-smart-doc.rar

    SpringBoot接口 - 如何生成接口文档之集成Smart-Doc上文我们看到可以通过Swagger系列可以快速生成API文档, 但是这种API文档生成是需要在接口上添加注解等,这表明这是一种侵入式方式; 那么有没有非侵入式方式呢, ...

    springboot常用配置- jdk8

    8. **并发改进**:JDK 8对并发包`java.util.concurrent`进行了优化,如`ForkJoinPool`和`CompletableFuture`。Spring Boot在异步处理和任务调度方面,可以结合JDK 8的并发特性实现高效并行执行。 9. **类型注解...

    jdk1.8 中文API.7z

    8. **并发更新类**:`java.util.concurrent`包中新增了`ConcurrentHashMap`的几个子类,如`ConcurrentSkipListMap`和`ConcurrentSkipListSet`,以及`Exchanger`和`CompletableFuture`,提供了更高效的并发控制和异步...

    jdk1.8.CHM

    5. HashMap和HashSet:两种常用的Map和Set实现,HashMap提供键值对的快速查找,HashSet存储不重复元素。 三、函数式编程 Java 1.8引入了函数式编程概念,主要体现在以下几个方面: 1. Lambda表达式:一种简洁的匿名...

    QuagganSelector:GW2 Web API 的测试应用程序 - 选择 Quaggan 图像

    3. **异步处理**:为了保持用户界面的响应性,避免阻塞UI线程,可能会采用异步处理API请求,如Java 8的CompletableFuture或使用ExecutorService来执行耗时操作。 4. **MVC模式**(Model-View-Controller):...

    开涛高可用高并发-亿级流量核心技术

    13.4 异步编排CompletableFuture 254 13.5 异步Web服务实现 257 13.6 请求缓存 259 13.7 请求合并 261 14 如何扩容 266 14.1 单体应用垂直扩容 267 14.2 单体应用水平扩容 267 14.3 应用拆分 268 14.4 数据库拆分 ...

Global site tag (gtag.js) - Google Analytics