Java异步编程：回调、Future和ExecutorService案例

原创 ╰+哭是因爲堅強的太久メ 2024-09-22 12:15 4阅读 0赞

在Java中，异步编程主要有三种方式：回调、Future和ExecutorService。下面我们将通过一些实例来详细解释。

1. **回调（Callback）**：

最简单的回调是方法参数传递，当任务完成后调用该方法。比如一个下载文件的Task，完成时调用`onDownloadCompleted(file)`：

```java
public class DownloadTask {
    private String file;

// 完成下载调用的方法
    public void onDownloadCompleted(String downloadedFile) {
        // 保存文件或者处理逻辑
        this.file = downloadedFile;
    }

// 下载任务的实现，这里只做模拟，实际中需要网络请求等
    public void download() {
        // 模拟下载过程
        Thread.sleep(3000);
        
        // 完成下载调用方法
        onDownloadCompleted("file_downloaded.pdf");
    }
}
```

2. **Future和CompletableFuture**：

Java 8引入了`Future`和`CompletableFuture`。`Future`表示一个待完成的操作，可以获取操作结果。`CompletableFuture`是`Future`的增强版，提供了更丰富的API。

例如使用`CompletableFuture`异步执行任务并获取结果：

```java
import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        // 创建一个异步任务
        CompletableFuture<String> future = new CompletableFuture<>();

// 同步调用future的thenApply方法，该方法会异步执行给定的逻辑
        future.thenApply(s -> "Task result: " + s), e -> {
            System.out.println("Error occurred: " + e.getMessage());
        });

// 现在可以获取结果了
        try {
            System.out.println("Result from CompletableFuture: " + future.get());  // 这里会阻塞直到Future完成
        } catch (Exception ex) {
            System.out.println("Error getting result from CompletableFuture: " + ex.getMessage());
        }
    }
}
```

3. **ExecutorService和Runnable**：

`ExecutorService`是Java线程池的一部分，用于异步执行任务。它提供了`submit(Runnable r)`方法，将一个任务包装成一个`Runnable`对象提交给线程池。

例如创建一个`ThreadPoolExecutor`并提交一个任务：

```java
import java.util.concurrent.*;

public class ExecutorServiceExample {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 1, 0L, System.currentTimeMillis(), new ArrayBlockingQueue<>(1)));

// 定义要异步执行的任务
        Runnable task = () -> {
            try {
                Thread.sleep(3000);  // 模拟耗时任务
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Task completed successfully.");
        };

// 提交任务到线程池执行
        executor.submit(task);

// 关闭线程池，释放资源
        executor.shutdown();

try {
            // 等待所有提交的任务完成
            while (!executor.isTerminated()) {
                Thread.sleep(500);  // 每隔一段时间检查一下状态
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

System.out.println("ExecutorServiceExample completed.");
    }
}
```

以上就是Java异步编程中回调、Future和ExecutorService的简单理解及示例。