Promise支持Java异步编程

最新推荐文章于 2024-02-19 14:05:51 发布

Kilin_Zhang

最新推荐文章于 2024-02-19 14:05:51 发布

阅读量507

点赞数

分类专栏： Java 文章标签： java Promise 异步编程

本文链接：https://blog.csdn.net/zhang_7150/article/details/121071976

版权

本文介绍如何在Java中利用Promise实现异步编程，通过类似JavaScript的链式调用来处理异步操作，提高代码的可读性和组织性。

摘要由CSDN通过智能技术生成

为异步编程提供一个容器，支持链式语法，与javascript的Promise使用相近。

源码：

package promise;

import javafx.util.Callback;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.SettableListenableFuture;

import java.util.*;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

/**
 * 为异步编程提供一个容器，支持链式语法，与javascript的Promise使用相近 <br>
 * Promise&lt;String&gt; promise = Promise.resolve("Kilin")     <br>
 *      .then(value -> value)                                   <br>
 *      .then(value -> throw new RuntimeException("test"))      <br>
 *      .error(e -> "Kilin");                                   <br>
 * System.out.println(promise.val());                           <br>
 *
 * @author zhang_7150@163.com
 * @version 1.0.0
 * @since 2021/10/30 08:47
 * @example
 *      // 静态 api <br>
 *      // resolve(T value) <br>
 *      // 生成一个处于完成状态的promise对象 <br>
 *      Promise&lt;String&gt; promise = Promise.resolve(""); <br>
 *
 *      // reject(Exception e) <br>
 *      // 生成一个处于完成状态并且包含异常的promise，如果未能使用.error处理异常，在调用val的时候会直接抛出指定的异常 <br>
 *      Promise&lt;String&gt; promise = Promise.reject(new RuntimeException()); <br>
 *
 *      // when(ListenableFuture&lt;T&gt; future) <br>
 *      // 通过 ListenableFuture 生成promise，此时promise将监听 ListenableFuture 的完成情况并作出相应的完成操作 <br>
 *      ListenableFuture&lt;String&gt; future = new SettableListenableFuture&lt;String&gt;(); <br>
 *      Promise&lt;String&gt; promise = Promise.when(future);               <br>
 *      new Thread(() -> { future.set(""); }).start();                      <br>
 *
 *      // all(Promise... promises) <br>
 *      // 包裹多个Promise并生成一个新的Promise对象，支持传入 null 做占位 <br>
 *      Promise&lt;String&gt; p1 = Promise.resolve("test");                       <br>
 *      Promise&lt;Integer&gt; p2 = Promise.resolve(100);                         <br>
 *      Promise&lt;Promise.Values&gt; promise = Promise.all(p1, p2, null);        <br>
 *
 *      // all(PromiseTransRunable&lt;T, Values&gt; trans, Promise... promises) <br>
 *      // 包裹多个Promise并生成一个新的Promise对象，通过传入 PromiseTransRunable 实例实现类型转换    <br>
 *      Promise&lt;String&gt; p1 = Promise.resolve("test");                       <br>
 *      Promise&lt;Integer&gt; p2 = Promise.resolve(100);                         <br>
 *      Promise&lt;String&gt; promise = Promise.all((e, values, p) -> {return "";}, p1, p2, null);    <br>
 *
 *      // val(Promise... promises) <br>
 *      // 获取所有指定的Promise的值，<br>
 *      // 注意：会等待所有指定的Promise对象完成之后，才会返回结果，<br>
 *      //      否则当前线程将一直处于等待状态，推荐使用 val(long timeout, TimeUnit timeUnit, Promise... promises)  <br>
 *      Promise&lt;String&gt; p1 = Promise.resolve("Kilin");                <br>
 *      Promise&lt;Integer&gt; p2 = Promise.resolve(18);                    <br>
 *      Promise.Values values = Promise.val(p1, p2, null);                  <br>
 *      System.out.println(values.get(0)); // output Kilin                  <br>
 *      System.out.println(values.get(1)); // output 18                     <br>
 *      System.out.println(values.get(2)); // output                        <br>
 *
 *      // val(long timeout, TimeUnit timeUnit, Promise... promises) <br>
 *      // 获取所有指定的Promise的值，当超过指定的timeout之后，将结束等待，并抛出TimeoutException错误 <br>
 *      Promise&lt;String&gt; p1 = Promise.resolve("Kilin");                <br>
 *      Promise&lt;Integer&gt; p2 = Promise.resolve(18);                    <br>
 *      Promise&lt;String&gt; p3 = new Promise<>(p -> {                     <br>
 *          new Thread(() -> {                                              <br>
 *              try {                                                       <br>
 *                  Thread.sleep(20);                                       <br>
 *              } catch (InterruptedException e) {                          <br>
 *                  p.reject(e);                                            <br>
 *              }                                                           <br>
 *              p.resolve("done");                                          <br>
 *          }).start();                                                     <br>
 *      });                                                                 <br>
 *
 *      try {                                                               <br>
 *          Promise.val(10, TimeUnit.MILLISECONDS, p1, p2, null, p3);       <br>
 *          Assert.assertEquals(1, 2);                                      <br>
 *      } catch (Throwable e) {                                             <br>
 *          // timeout                                                      <br>
 *          Assert.assertTrue(e.getCause() instanceof TimeoutException);    <br>
 *      }                                                                   <br>
 *
 *      // 实例 api <br>
 *      // Promise(PromiseRunable&lt;T&gt; runner) <br>
 *      // 构造函数，通过指定一个 PromiseRunable 对象来生成Promise实例 <br>
 *      // Promise对象会通过