本文目录导读：
- 使用接口实现回调（最基础的方式）
- 使用Lambda表达式（Java 8+）
- 使用CompletableFuture（推荐方式）
- 使用Future和Callable
- 使用事件监听器模式（适用于UI或复杂场景）
- 使用响应式编程（RxJava）
- 最佳实践建议
在Java中实现异步回调有多种方式，下面我为你介绍几种常见且实用的实现方法,从基础到进阶。
使用接口实现回调（最基础的方式）
// 定义回调接口
interface Callback {
void onSuccess(String result);
void onFailure(Exception e);
}
// 异步任务执行器
class AsyncTask {
public void execute(Callback callback) {
new Thread(() -> {
try {
// 模拟耗时操作
Thread.sleep(2000);
// 模拟成功
String result = "任务执行成功";
callback.onSuccess(result);
} catch (Exception e) {
callback.onFailure(e);
}
}).start();
}
}
// 使用示例
public class CallbackExample {
public static void main(String[] args) {
AsyncTask task = new AsyncTask();
task.execute(new Callback() {
@Override
public void onSuccess(String result) {
System.out.println("成功: " + result);
}
@Override
public void onFailure(Exception e) {
System.out.println("失败: " + e.getMessage());
}
});
System.out.println("主线程继续执行...");
}
}
使用Lambda表达式（Java 8+）
// 函数式接口
@FunctionalInterface
interface AsyncCallback {
void onComplete(String result);
}
// 异步任务
class AsyncExecutor {
public void runAsync(AsyncCallback callback) {
CompletableFuture.runAsync(() -> {
try {
Thread.sleep(1000);
callback.onComplete("任务完成");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
}
}
// 使用
public class LambdaCallback {
public static void main(String[] args) {
AsyncExecutor executor = new AsyncExecutor();
executor.runAsync(result -> System.out.println(result));
System.out.println("主线程继续执行...");
}
}
使用CompletableFuture（推荐方式）
import java.util.concurrent.CompletableFuture;
public class CompletableFutureExample {
public static void main(String[] args) {
// 1. 创建异步任务
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
// 模拟耗时操作
sleep(2000);
return "任务结果";
});
// 2. 注册回调
future.thenAccept(result -> {
System.out.println("成功回调: " + result);
}).exceptionally(ex -> {
System.out.println("异常回调: " + ex.getMessage());
return null;
});
// 3. 另一个例子：链式调用
CompletableFuture.supplyAsync(() -> "Hello")
.thenApply(s -> s + " World")
.thenAccept(System.out::println)
.exceptionally(ex -> {
System.err.println("错误: " + ex);
return null;
});
System.out.println("主线程继续执行...");
// 等待异步任务完成（仅用于演示）
sleep(3000);
}
private static void sleep(long millis) {
try {
Thread.sleep(millis);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
使用Future和Callable
import java.util.concurrent.*;
public class FutureExample {
public static void main(String[] args) throws Exception {
ExecutorService executor = Executors.newFixedThreadPool(2);
// 提交异步任务
Future<String> future = executor.submit(() -> {
Thread.sleep(2000);
return "异步结果";
});
// 方式1：阻塞获取结果
// String result = future.get();
// 方式2：轮询检查完成状态（简单回调模拟）
new Thread(() -> {
while (!future.isDone()) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
break;
}
}
try {
String result = future.get();
System.out.println("回调：任务完成，结果：" + result);
} catch (Exception e) {
System.out.println("回调：任务失败：" + e.getMessage());
}
}).start();
System.out.println("主线程继续执行...");
executor.shutdown();
}
}
使用事件监听器模式（适用于UI或复杂场景）
import java.util.*;
// 事件类
class AsyncEvent extends EventObject {
private final String message;
public AsyncEvent(Object source, String message) {
super(source);
this.message = message;
}
public String getMessage() {
return message;
}
}
// 监听器接口
interface AsyncListener extends EventListener {
void onEvent(AsyncEvent event);
}
// 异步任务管理器
class AsyncManager {
private final List<AsyncListener> listeners = new ArrayList<>();
public void addListener(AsyncListener listener) {
listeners.add(listener);
}
public void removeListener(AsyncListener listener) {
listeners.remove(listener);
}
public void executeAsync() {
new Thread(() -> {
try {
Thread.sleep(2000);
AsyncEvent event = new AsyncEvent(this, "任务完成");
// 通知所有监听器
for (AsyncListener listener : listeners) {
listener.onEvent(event);
}
} catch (Exception e) {
AsyncEvent errorEvent = new AsyncEvent(this, "错误: " + e.getMessage());
for (AsyncListener listener : listeners) {
listener.onEvent(errorEvent);
}
}
}).start();
}
}
// 使用示例
public class EventExample {
public static void main(String[] args) {
AsyncManager manager = new AsyncManager();
// 注册回调
manager.addListener(event ->
System.out.println("收到事件: " + event.getMessage())
);
manager.executeAsync();
System.out.println("主线程继续执行...");
}
}
使用响应式编程（RxJava）
import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.schedulers.Schedulers;
public class RxJavaExample {
public static void main(String[] args) {
Observable.create(emitter -> {
// 异步操作
try {
Thread.sleep(2000);
emitter.onNext("RxJava结果");
emitter.onComplete();
} catch (Exception e) {
emitter.onError(e);
}
})
.subscribeOn(Schedulers.io()) // 在IO线程执行
.observeOn(Schedulers.single()) // 在单线程观察结果
.subscribe(
result -> System.out.println("成功: " + result),
error -> System.err.println("错误: " + error),
() -> System.out.println("完成")
);
System.out.println("主线程继续执行...");
// 等待异步完成
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
最佳实践建议
- 推荐使用CompletableFuture：Java 8引入，功能强大，支持链式调用和组合
- 考虑线程安全：回调中访问共享资源时注意同步
- 错误处理：始终处理异常情况
- 避免回调地狱：使用CompletableFuture或响应式库简化嵌套回调
- 上下文传递：如需传递上下文，考虑使用设计模式或线程局部变量
根据你的具体场景选择合适的方式，如果是新项目,强烈推荐使用CompletableFuture。
