Java中异步处理CompletableFuture
Java中异步处理CompletableFuture
异步处理简单来说就是另起一个线程处理，使程序不至于阻塞到某一步，导致后续代码无法执行。
异步处理的方法有很多，懒的话直接 new Thread(() -> {}).start(); ，也不是不行。但是这样会让
自己显得很low，不能向别人装13。再进一步，其实可以用线程池来管理，但是各种线程之间的通信也
很麻烦，还要注意线程安全的问题。jdk1.8提供了CompletableFuture类，扩展了Future接口，可以帮
助我们简化异步处理。
一个无返回值的异步处理过程：
public static void main(String[] args) throws InterruptedException {
CompletableFuture.runAsync(() -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread() + "-----"
+System.currentTimeMillis());
});
System.out.println(Thread.currentThread() + "-----"
+System.currentTimeMillis());
// 保证主线程不早于异步线程结束
Thread.sleep(10000);
}
打印结果：
Thread[main,5,main]-----1582874573581
Thread[ForkJoinPool.commonPool-worker-3,5,main]-----1582874574584
从结果看，异步方法中的延迟1000ms，并没有影响到主线程的运行。
主线程中的sleep(10000)，主要是防止主线程过早结束，因为CompletableFuture默认使用的是
ForkJoinPool，此线程池创建的线程为守护线程，如果非守护线程全部结束，其也会自动结束。
上面演示的为没有返回值的异步，下面演示有返回值的异步：
public static void main(String[] args) throws InterruptedException {
CompletableFuture<Long> future = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
long l = System.currentTimeMillis();
System.out.println(Thread.currentThread() + "-----" + l);
// 返回当前时间
return l;
});
try {
// 获取异步执行结果
System.out.println(future.get());
} catch (ExecutionException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread() + "-----" + System.currentTimeMillis());
Thread.sleep(10000);
}
运行结果：
Thread[ForkJoinPool.commonPool-worker-3,5,main]-----1582875356876
1582875356876
Thread[main,5,main]-----1582875356914
根据结果看，异步方法执行了，future.get()阻塞了，获取到结果后继续执行后续任务。
因为上面说了，CompletableFuture实现了Future接口，当然可以用Future的get方法获取结果，但是
我们都知道，Future的get方法是会阻塞的，这对于我们异步执行没什么作用啊。对了，因为
CompletableFuture的正确用法不是直接使用get阻塞来获取结果。
下面演示非阻塞获取异步结果：
public static void main(String[] args) throws InterruptedException {
CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
long l = System.currentTimeMillis();
System.out.println(Thread.currentThread() + "-----" + l);
return l;
}).thenAccept(time -> {
System.out.println("thenAccept: " + time);
});
System.out.println(Thread.currentThread() + "-----" + System.currentTimeMillis());
Thread.sleep(10000);
}
运行结果：
Thread[main,5,main]-----1582875824352
Thread[ForkJoinPool.commonPool-worker-3,5,main]-----1582875825351
thenAccept: 1582875825351
根据结果来看，主线程没有被阻塞，最终的异步执行的方法结果也取到了。
上面使用了链式调用的thenAccept(Consumer action)，这个方法接受一个函数式接口
Consumer，Consumer这个函数式接口表示接受一个参数，不返回值。其实就是回调了这个
Consumer，把上一步的结果作为参数传递进来。
上面只是CompletableFuture的一些小功能，下面演示多个CompletableFuture串行执行：
CompletableFuture<List<Integer>> task1 = CompletableFuture.supplyAsync(() -> {
System.out.println("任务1启动，开始创建1000个随机的整数");
List<Integer> list = new ArrayList<>();
Random random = new Random();
for (int i = 0; i < 1000; i++) {
list.add(random.nextInt(10000));
}
System.out.println("任务1执行成功");
return list;
});
task1.thenApply(list -> {
System.out.println("任务2启动，将任务1中的1000个随机数排序，从大到小");
list.sort((val1, val2) -> val2 - val1);
System.out.println("任务2执行成功");
return list;
}).thenAccept(list -> {
System.out.println("所有任务执行完成，结果是：" + list);
});
System.out.println(Thread.currentThread());
Thread.sleep(10000);
}
运行结果：
任务1启动，开始创建1000个随机的整数
任务1执行成功
Thread[main,5,main]
任务2启动，将任务1中的1000个随机数排序，从大到小
任务2执行成功
所有任务执行完成，结果是：[9994, 9979, 9968, 9949, 9937, 9931, 9931, 9912, 9899 ...
多个异步任务之间串行执行，用起来很方便，而且CompletableFuture的链式调用方法都支持lambda
表达式，写起来更加简洁，流程也很清晰。
有串行执行当然就有并行执行，多个CompletableFuture并行执行：
public static void main(String[] args) throws InterruptedException {
int[] array = new int[10000];
Random random = new Random();
for (int i = 0; i < array.length; i++) {
array[i] = random.nextInt(100000);
}
// 并行执行
CompletableFuture<Long> task1 = CompletableFuture.supplyAsync(() -> bubbleSort(array));
// 并行执行
CompletableFuture<Long> task2 = CompletableFuture.supplyAsync(() -> insertionSort(array));
// 使用最先完成的
CompletableFuture.anyOf(task1, task2).thenAccept(obj -> {
System.out.println("最终结果为：" + obj);
});
System.out.println(Thread.currentThread());
Thread.sleep(10000);
}
// 冒泡排序，返回排序时间
private static long bubbleSort(int[] array) {
long begin = System.currentTimeMillis();
for (int i = 0; i < array.length - 1; i++) {
for (int j = 0; j < array.length - i - 1; j++) {
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
long time = System.currentTimeMillis() - begin;
System.out.println("AsyncMain.bubbleSort " + time);
return time;
}
// 插入排序，返回排序时间
private static long insertionSort(int[] array) {
long begin = System.currentTimeMillis();
for (int i = 1; i < array.length; i++) {
int temp = array[i];
int j = i;
while (j > 0 && temp < array[j - 1]) {
array[j] = array[j - 1];
j--;
}
array[j] = temp;
}
long time = System.currentTimeMillis() - begin;
System.out.println("AsyncMain.insertionSort " + time);
return time;
}
运行结果为：
Thread[main,5,main]
AsyncMain.insertionSort 7
最终结果为：7
AsyncMain.bubbleSort 83
观察结果，插入排序先执行完毕，则优先使用插入排序的结果，冒泡排序没有被停止，也会继续执行，
但不需要他的结果了。
异常处理
异步处理中，lambda表达式中的异常抛不出来，需要使用exceptionally或者handle：
public static void main(String[] args) throws InterruptedException {
CompletableFuture.runAsync(() -> {
int a = 1/0;
}).exceptionally(throwable -> {
throwable.printStackTrace();
return null;
});
System.out.println(Thread.currentThread());
Thread.sleep(10000);
}
public static void main(String[] args) throws InterruptedException {
CompletableFuture.runAsync(() -> {
int a = 1/0;
}).handle((aVoid, throwable) -> {
if (throwable != null){
throwable.printStackTrace();
}
System.out.println("handle");
return null;
});
System.out.println(Thread.currentThread());
Thread.sleep(10000);
}
两者的区别是，exceptionally是当发生异常时执行，而handle则总是执行，不管是否发生异常。
其他总结：
CompletableFuture方法中带有Async都会在线程池中重开一个线程，而不带Async的使用已有的
线程。
如果调用了CompletableFuture的cancel方法，则再次调用get会抛CancellationException异常。
可以手动创建线程池替换默认的ForkjoinPool。