将一个简单远程调用的方式例子改为异步调用

将一个简单远程调用的方式例子改为异步调用

package com.xsxy.asynctest.test03;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * 将一个简单远程调用的方式例子改为异步调用
 */
public class Test04CompletableFuturePractice {

    public static void main(String[] args) {
        List<String> ipList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            ipList.add("192.168.0." + i);
        }
        syncMethod(ipList);
        AsyncMethod(ipList);
    }

    /**
     * 同步顺序调用耗时 time:10138
     *
     * @param ipList
     */
    public static void syncMethod(List<String> ipList) {
        long start = System.currentTimeMillis();
        ipList.forEach(ip -> {
            rpcCall(ip, 8080);
        });
        System.out.println("time:" + (System.currentTimeMillis() - start));
    }

    /**
     * 异步调用耗时 time:4029
     *
     * @param ipList
     */
    public static void AsyncMethod(List<String> ipList) {
        long start = System.currentTimeMillis();
        // 同步调用转异步
        List<CompletableFuture<String>> completableFutureList = ipList.stream().map(ip -> CompletableFuture.supplyAsync(() -> rpcCall(ip, 9090)))
                .collect(Collectors.toList());

        // 阻塞等待所有调用都结束
        List<String> resList = completableFutureList.stream().map(CompletableFuture::join).collect(Collectors.toList());
        // resList.forEach(System.out::println);

        System.out.println("time:" + (System.currentTimeMillis() - start));
    }


    public static String rpcCall(String ip, int port) {
        System.out.println("rpcCall=ip:" + ip + ",port:" + port);
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {

        }
        return "res" + port;
    }
}

其他completableFuture的使用例子

package com.xsxy.asynctest.test03;

import java.util.concurrent.*;
import java.util.function.Consumer;
import java.util.function.Supplier;

public class Test01CompletableFutureSet {
    public static final int AVALIABLE_PROCESSORS = Runtime.getRuntime().availableProcessors();
    public static ThreadPoolExecutor executor = new ThreadPoolExecutor(AVALIABLE_PROCESSORS, AVALIABLE_PROCESSORS, 1, TimeUnit.MINUTES,
            new LinkedBlockingQueue<>(5), new ThreadPoolExecutor.CallerRunsPolicy());


    public static void main(String[] args) throws Exception {
        // waitNotify();
        // runAsync();
        // runAsync1WithBizExecutor();
        // supplyAsync();
        // thenRun();
        thenAccept();
    }

    /**
     * 这里使用CompletableFuture实现了 通知等待模型，主线程调用future的get()方法等待future返回结果，一开始由于future结果没有设置，
     * 所以主线程被阻塞挂起，等异步任务休眠3s，然后调用future的complete方法模拟主线程等待的条件完成，这时候主线程就会从get()方法返回。
     */
    public static void waitNotify() throws ExecutionException, InterruptedException, TimeoutException {
        CompletableFuture completableFuture = new CompletableFuture();
        executor.execute(() -> {
            System.out.println("executor sleep 3 seconds");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {

            }

            completableFuture.complete("executor done");
        });

        System.out.println("main wait completableFurture result");
        // 阻塞获取completableFuture结果
        System.out.println(completableFuture.get());
        // 设置超时时间，超时时会保timeoutException异常
        // System.out.println(completableFuture.get(1, TimeUnit.SECONDS));
        System.out.println("main end");
    }

    /**
     * 实现无返回值的异步计算：当你想异步执行一个任务，并且不需要任务的执行结果时可以使用该方法，比如异步打日志，异步做消息通知等
     * 在默认情况下，runAsync(Runnablerunnable)方法是使用整个JVM内唯一的ForkJoinPool.commonPool()线程池来执行异步任务的，
     * 使用runAsync (Runnable runnable, Executor executor)
     */
    public static void runAsync() throws Exception {
        CompletableFuture future = CompletableFuture.runAsync(() -> {
            System.out.println("execute completableFuture task");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {

            }
        });

        System.out.println("mian");
        // 无返回值
        System.out.println(future.get());
        System.out.println("main end");
    }

    /**
     * 使用自定义线程池 实现无返回值的异步计算
     */
    public static void runAsync1WithBizExecutor() throws Exception {
        // 使用自定义的线程池
        CompletableFuture future = CompletableFuture.runAsync(() -> {
            System.out.println("run completableFuture task");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {

            }
        }, executor);

        System.out.println("main");
        System.out.println(future.get());
        System.out.println("main end");
    }

    /**
     * 实现有返回值的异步计算
     * 在默认情况下，supplyAsync(Supplier<U> supplier)方法是使用整个JVM内唯一的ForkJoinPool.commonPool()线程池来执行异步任务的，
     * 使用supply-Async(Supplier<U> supplier,Executor executor)方法允许我们使用自己制定的线程池来执行异步任务
     */
    public static void supplyAsync() throws Exception {
        CompletableFuture future = CompletableFuture.supplyAsync(new Supplier<Object>() {
            @Override
            public Object get() {
                System.out.println("completableFuture supplyAsync run");
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (Exception e) {

                }
                // 返回异步计算结果
                return "supplyAsync return";
            }
        });

        System.out.println("main");
        System.out.println(future.get());
        System.out.println("main end");
    }

    /**
     * 基于thenRun实现异步任务，执行完毕后，激活异步任务B执行，需要注意的是，这种方式激活的异步任务B是拿不到任务A的执行结果的
     */
    public static void thenRun() throws ExecutionException, InterruptedException {
        CompletableFuture future = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                System.out.println("completableFuture run");
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (Exception e) {

                }
                return "completableFuture supplyAsync return";
            }
        });

        CompletableFuture futuretwo = future.thenRun(() -> {
            System.out.println("thenRun  --");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {

            }
        });

        System.out.println("main");
        System.out.println(futuretwo.get());
        System.out.println("main end");
    }

    /**
     * 基于thenAccept实现异步任务，执行完毕后，激活异步任务B执行，需要注意的是，这种方式激活的异步任务B是可以拿到任务A的执行结果的
     */
    public static void thenAccept() throws ExecutionException, InterruptedException {
        CompletableFuture future = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                System.out.println("completableFuture run");
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (Exception e) {

                }
                return "completableFuture supplyAsync return";
            }
        });

        CompletableFuture futuretwo = future.thenAccept(new Consumer<String>() {
            @Override
            public void accept(String o) {
                System.out.println(o);
            }
        });

        System.out.println("main");
        System.out.println(futuretwo.get());
        System.out.println("main end");
    }
}

三

package com.xsxy.asynctest.test03;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;


public class Test02TwoCompletableFuture {


    /**
     * CompletableFuture功能强大的原因之一是其可以让两个或者多个Completable-Future进行运算来产生结果
     * <p>
     * main函数中首先调用方法doSomethingOne("123")开启了一个异步任务，并返回了对应的CompletableFuture对象，
     * 我们取名为future1，然后在future1的基础上调用了thenCompose方法，企图让future1执行完毕后，激活使用其结果作
     * 为doSomethingTwo(String companyId)方法的参数的任务
     */
    public static void main(String[] args) throws Exception {
        // 串行
        // testThenCompose();
        // 并行计算
        // testThencombine();
        // 批量
        testAllOf();

    }

    /**
     * 基于thenCompose实现当一个CompletableFuture执行完毕后，执行另外一个CompletableFuture
     */
    public static void testThenCompose() throws Exception {
        CompletableFuture<String> future = doSomething1("123").thenCompose(id -> doSomething2(id));
        // CompletableFuture<String> future = doSomething1("123").thenCompose(Test02TwoCompletableFuture::doSomething2);
        System.out.println("main");
        System.out.println(future.get());
        System.out.println("main end");
    }

    /**
     * 基于thenCombine实现当一个CompletableFuture执行完毕后，执行另外一个CompletableFuture
     */
    public static void testThencombine() throws Exception {
        // CompletableFuture<String> future = doSomething1("123").thenCombine(doSomething2("456"), (str1, str2) -> str1 + ":" + str2);
        CompletableFuture<String> future = doSomething1("123").thenCombine(doSomething2("456"), (str1, str2) -> {
            return str1 + ":" + str2;
        });
        System.out.println("main");
        System.out.println(future.get());
        System.out.println("main end");
    }

    /**
     * 基于allOf等待多个并发运行的CompletableFuture任务执行完毕
     *
     * 调用了四次doSomethingOne方法，分别返回一个CompletableFuture对象，然后收集这些CompletableFuture到futureList列表。
     * 调用allOf方法把多个CompletableFuture转换为一个result，代码3在result上调用get()方法会阻塞调用线程，
     * 直到futureList列表中所有任务执行完毕才返回
     */
    public static void testAllOf() throws ExecutionException, InterruptedException {
        List<CompletableFuture<String>> futureList = new ArrayList<>();
        futureList.add(doSomething1("1"));
        futureList.add(doSomething1("2"));
        futureList.add(doSomething1("3"));
        futureList.add(doSomething1("4"));

        CompletableFuture<Void> res = CompletableFuture.allOf(futureList.toArray(new CompletableFuture[futureList.size()]));
        System.out.println("main");
        // 等待所有的future执行完毕
        System.out.println(res.get());
        System.out.println("main end ");

    }


    public static CompletableFuture<String> doSomething1(String id) {
        return CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                System.out.println("doSomething1 execute");
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (Exception e) {

                }
                return id;
            }
        });
    }

    public static CompletableFuture<String> doSomething2(String id) {
        return CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                System.out.println("doSomething2 execute");
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (Exception e) {

                }
                return id + "doSomething2";
            }
        });
    }
}

四

package com.xsxy.asynctest.test03;

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

public class Test03CompletableFutureWithException {
    /**
     * 之前的测试completableFuture都是基于流程正常流转，如果出现异常怎么处理
     */
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<String> future = new CompletableFuture<>();

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
                // 测试异常
                if (true) {
                    throw new RuntimeException("");
                }
                future.complete("complete");
            } catch (Exception e) {
                e.printStackTrace();
                // 先注释掉， 和下边的输出语句同时放开（注释掉32，放开33）
                // future.completeExceptionally(e);
            }


        }, "thread-1").start();

        System.out.println("main");
        System.out.println(future.get());
        // System.out.println(future.exceptionally(t -> "aaaaaa").get());
        System.out.println("main end");
    }
}