书接上文

3. CompletableFuture

CompletableFuture 是 Java 8 中新增的类，提供了更为强大的异步编程支持。它可以将多个异步任务组合成一个整体，并且可以处理异常情况。

例如，可以使用 CompletableFuture 来实现异步任务的串行执行：

public class MyTask {
    public CompletableFuture<String> doTaskAsync() {
        CompletableFuture<String> future = new CompletableFuture<>();
        Thread t = new Thread(() -> {
            String result = doTask();
            future.complete(result);
        });
        t.start();
        return future;
    }

    private String doTask() { // 模拟耗时操作
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "result";
    }
}

public class Test {
    public static void main(String[] args) throws Exception {
        MyTask task = new MyTask();
        CompletableFuture<String> future1 = task.doTaskAsync();
        CompletableFuture<String> future2 = future1.thenApply(result -> result + "2");
        CompletableFuture<String> future3 = future2.thenApply(result -> result + "3");

        String result = future3.get();
        System.out.println("Result: " + result);
    }
}

在上面的例子中，使用 thenApply() 方法将多个异步任务串行执行，并且可以对每个任务的结果进行处理。

4. RxJava

RxJava 是一个基于响应式编程的框架，可以用于处理异步任务。它提供了丰富的操作符来方便地处理异步数据流。

例如，在 RxJava 中可以使用 flatMap 操作符实现多个异步任务的并行执行：

Observable.fromCallable(() -> doTask1())
    .subscribeOn(Schedulers.io())
    .flatMap(result1 -> Observable.fromCallable(() -> doTask2()))
    .subscribeOn(Schedulers.io())
    .flatMap(result2 -> Observable.fromCallable(() -> doTask3()))
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(result3 -> {
        // 处理结果
    }, throwable -> {
        // 处理异常
    });

在上面的例子中，使用 fromCallable() 方法将每个任务封装成一个 Observable，然后使用 flatMap() 方法将多个 Observable 合并成一个，并且可以在其中指定线程池来处理任务。最后使用 observeOn() 方法将结果切换到主线程进行处理。

5. Kotlin 协程

Kotlin 协程是一种轻量级的异步编程方式，它把异步任务看作是挂起函数（suspend function），通过协程上下文（CoroutineContext）和调度器（Dispatcher）来管理挂起函数的执行。

例如，在 Kotlin 协程中可以使用 async 和 await 函数实现多个异步任务的并行执行：

val result1 = async { doTask1() }
val result2 = async { doTask2() }
val result3 = async { doTask3() }

val finalResult = result1.await() + result2.await() + result3.await()

在上面的例子中，使用 async 函数将每个任务封装成一个 Deferred 对象，并且可以同时执行多个任务。最后使用 await 函数等待所有任务完成并获取结果。

总结

以上是几种常用的异步编程方式，每种方式都有其优缺点和适用场景。需要根据具体情况选择合适的方式来处理异步任务，以提高程序的并发性和响应性能。