Java两种异步编程模型-CSDN博客

本文链接：https://blog.csdn.net/u014333212/article/details/148281709

Java 的两种主要异步编程模型

Java 提供了两种主要的异步编程模型，分别是回调模型和Future/Promise 模型。这两种模型代表了处理异步操作的不同方法，各有优劣。以下是对这两种模型的详细讲解：

1. 回调模型 (Callback Model)

回调模型是一种基于通知的异步处理方式，通过将回调函数（方法）传递给异步操作，当操作完成时调用这些函数来处理结果或错误。

核心特点

事件驱动：基于"完成时通知我"的思想
控制反转：由被调用者决定何时调用回调函数
非阻塞：不等待操作完成即可继续执行

实现方式

基于接口的传统回调

interface ResultCallback {
    void onSuccess(String result);
    void onFailure(Exception ex);
}

class AsyncService {
    public void performTask(ResultCallback callback) {
        new Thread(() -> {
            try {
                // 执行耗时操作
                String result = heavyComputation();
                callback.onSuccess(result);
            } catch (Exception e) {
                callback.onFailure(e);
            }
        }).start();
    }
    
    private String heavyComputation() {
        // 模拟耗时计算
        return "计算结果";
    }
}

// 使用回调
AsyncService service = new AsyncService();
service.performTask(new ResultCallback() {
    @Override
    public void onSuccess(String result) {
        System.out.println("成功: " + result);
    }
    
    @Override
    public void onFailure(Exception ex) {
        System.out.println("失败: " + ex.getMessage());
    }
});

使用 Lambda 表达式（Java 8+）

interface SuccessCallback {
    void onSuccess(String result);
}

interface FailureCallback {
    void onError(Exception ex);
}

class ModernAsyncService {
    public void performTask(SuccessCallback onSuccess, FailureCallback onError) {
        new Thread(() -> {
            try {
                String result = heavyComputation();
                onSuccess.onSuccess(result);
            } catch (Exception e) {
                onError.onError(e);
            }
        }).start();
    }
    
    private String heavyComputation() {
        return "计算结果";
    }
}

// 使用 Lambda 简化回调
ModernAsyncService service = new ModernAsyncService();
service.performTask(
    result -> System.out.println("成功: " + result),
    ex -> System.out.println("失败: " + ex.getMessage())
);

优点

简单直观，容易理解
灵活性高，可以针对不同结果执行不同操作
代码执行顺序明确
适合事件驱动的场景（如UI响应、网络通知等）

缺点

容易导致回调地狱（嵌套回调）
错误处理分散
难以实现复杂的控制流程（如并行、顺序、条件执行）
代码可读性在复杂场景下降低

2. Future/Promise 模型

Future/Promise 模型代表了一种基于值的异步编程范式，它将异步操作的结果表示为一个可能尚未完成的值（Future），并提供了操作这些值的方法。

核心概念

Future：代表一个尚未完成的计算结果
Promise：Future 的可写入视图，允许设置结果或错误

实现方式

传统 Future (Java 5+)

import java.util.concurrent.*;

class FutureService {
    private final ExecutorService executor = Executors.newCachedThreadPool();
    
    public Future<String> performTask() {
        return executor.submit(() -> {
            // 执行耗时操作
            Thread.sleep(1000);
            return "计算结果";
        });
    }
    
    public void shutdown() {
        executor.shutdown();
    }
}

// 使用 Future
FutureService service = new FutureService();
Future<String> future = service.performTask();

try {
    String result = future.get(); // 阻塞等待结果
    System.out.println("结果: " + result);
} catch (Exception e) {
    System.out.println("错误: " + e.getMessage());
} finally {
    service.shutdown();
}

CompletableFuture (Java 8+)

import java.util.concurrent.CompletableFuture;

class ModernFutureService {
    public CompletableFuture<String> performTask() {
        return CompletableFuture.supplyAsync(() -> {
            try {
                // 模拟耗时操作
                Thread.sleep(1000);
                return "计算结果";
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
    }
}

// 使用 CompletableFuture
ModernFutureService service = new ModernFutureService();
CompletableFuture<String> future = service.performTask();

// 非阻塞方式处理结果
future.thenAccept(result -> System.out.println("成功: " + result))
      .exceptionally(ex -> {
          System.out.println("失败: " + ex.getMessage());
          return null;
      });

// 等待异步操作完成
Thread.sleep(2000);

组合 CompletableFuture

CompletableFuture<String> future1 = service.performTask1();
CompletableFuture<Integer> future2 = service.performTask2();

// 组合两个 future
CompletableFuture<String> combined = future1.thenCombine(
    future2,
    (result1, result2) -> result1 + " 和 " + result2
);

// 顺序执行
CompletableFuture<String> sequence = service.performTask1()
    .thenCompose(result -> service.performTask2(result))
    .thenApply(result -> "最终结果: " + result);

优点

可组合性强，支持复杂的异步流程
提供丰富的操作（map, filter, combine等）
中心化的错误处理
避免回调地狱
支持异步计算的链式操作

缺点

概念相对复杂
某些操作可能导致线程阻塞（如get()）
错误传播需要特别处理
调试较为复杂

3. 两种模型的比较

特性	回调模型	Future/Promise 模型
编程风格	事件驱动	函数式/声明式
组合能力	弱（容易形成嵌套）	强（支持链式和并行）
易用性	简单场景下直观	复杂场景下更清晰
错误处理	分散	集中
控制流	难以表达复杂流程	支持复杂流程控制
适用场景	简单异步通知、UI事件	复杂异步流程、数据转换
Java 支持	全版本支持	Java 5+ (Future) Java 8+ (CompletableFuture)

4. 实际应用场景

回调模型适用场景

UI 事件处理

button.addActionListener(event -> System.out.println("按钮被点击"));

简单的异步任务通知

executor.execute(() -> {
    // 执行任务
    callback.onComplete("完成");
});

HTTP 客户端

// OkHttp
client.newCall(request).enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {
        // 处理失败
    }
    
    @Override
    public void onResponse(Call call, Response response) {
        // 处理响应
    }
});

Future/Promise 模型适用场景

复杂的异步数据处理流程

CompletableFuture.supplyAsync(() -> fetchUserData(userId))
    .thenApply(user -> enrichUserData(user))
    .thenApply(richUser -> convertToDTO(richUser))
    .thenAccept(dto -> sendResponse(dto))
    .exceptionally(ex -> handleError(ex));

并行执行多个异步任务

CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> fetchData("source1"));
CompletableFuture<String> task2 = CompletableFuture.supplyAsync(() -> fetchData("source2"));
CompletableFuture<String> task3 = CompletableFuture.supplyAsync(() -> fetchData("source3"));

CompletableFuture.allOf(task1, task2, task3)
    .thenRun(() -> {
        // 所有任务完成
        String result1 = task1.join();
        String result2 = task2.join();
        String result3 = task3.join();
        processResults(result1, result2, result3);
    });

超时处理和竞争条件

CompletableFuture<String> future = service.performTask()
    .completeOnTimeout("默认结果", 1, TimeUnit.SECONDS)
    .exceptionally(ex -> "发生错误: " + ex.getMessage());

// 或者使用 anyOf 获取最快的结果
CompletableFuture<Object> fastest = CompletableFuture.anyOf(
    service.fetchFromSource1(),
    service.fetchFromSource2(),
    service.fetchFromSource3()
);