教你java中如何判断代码中异步操作是否完成

在Java中，异步操作的实现方式有很多，最常见的是通过多线程和并发工具类来实现。

在这个示例中，我们定义了一个Callable任务，使用ExecutorService提交该任务，并通过Future对象检查任务是否完成以及获取任务结果。

java

import java.util.concurrent.*;

public class FutureExample {
public static void main(String[] args) {
// 创建一个固定线程池
ExecutorService executor = Executors.newFixedThreadPool(2);

// 定义一个Callable任务，任务会返回一个字符串结果
Callable callableTask = () -> {
// 模拟任务执行耗时
Thread.sleep(2000);
return "Task completed!";
};

// 提交任务并获取Future对象
Future future = executor.submit(callableTask);

try {
// 判断任务是否完成
while (!future.isDone()) {
System.out.println("Task is still not done...");
Thread.sleep(500); // 每隔500毫秒检查一次任务是否完成
}

// 获取任务结果
String result = future.get();
System.out.println("Task result: " + result);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
} finally {
// 关闭线程池
executor.shutdown();
}
}
}

异步操作在Web应用中的实践

通过异步任务并行执行多个HTTP请求，从而减少响应时间。

这个示例展示了如何使用ExecutorService并行执行两个HTTP请求，并获取其结果.

java

import java.util.concurrent.*;
import java.net.*;
import java.io.*;

public class AsyncHttpExample {
public static void main(String[] args) throws InterruptedException, ExecutionException {
// 创建一个固定线程池
ExecutorService executor = Executors.newFixedThreadPool(4);

// 定义第一个HTTP请求任务
Callable task1 = () -> fetch("http://example.com/api/endpoint1");
// 定义第二个HTTP请求任务
Callable task2 = () -> fetch("http://example.com/api/endpoint2");

// 提交任务并获取Future对象
Future future1 = executor.submit(task1);
Future future2 = executor.submit(task2);

// 获取任务结果
String result1 = future1.get();
String result2 = future2.get();

System.out.println("Result 1: " + result1);
System.out.println("Result 2: " + result2);

// 关闭线程池
executor.shutdown();
}

// 执行HTTP请求的方法
private static String fetch(String urlString) throws IOException {
URL url = new URL(urlString);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");

BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
String inputLine;
StringBuilder content = new StringBuilder();
while ((inputLine = in.readLine()) != null) {
content.append(inputLine);
}

in.close();
return content.toString();
}
}

在实际开发中，异步操作不仅仅是提交和获取任务结果，还需要考虑错误处理、结果组合和异步流等高级技巧。

错误处理和异常传播

异步操作中发生的异常需要适当地处理和传播，确保程序的健壮性。

在这个示例中，我们模拟了一个任务抛出异常，并使用exceptionally方法处理异常。

java

import java.util.concurrent.*;

public class CompletableFutureErrorHandling {
public static void main(String[] args) {
// 创建一个CompletableFuture任务
CompletableFuture future = CompletableFuture.supplyAsync(() -> {
if (true) {
throw new RuntimeException("Something went wrong!");
}
return "Hello, CompletableFuture!";
});

// 处理结果或异常
future.thenAccept(result -> System.out.println("Result: " + result))
.exceptionally(ex -> {
// 异常处理
System.out.println("Exception: " + ex);
return null;
});

try {
// 主线程等待异步任务完成
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

结果组合和异步流

使用CompletableFuture的thenCombine方法来组合两个异步任务的结果。

以下是一个使用thenCombine方法组合两个异步任务结果的示例：

java

import java.util.concurrent.*;

public class CompletableFutureCombine {
public static void main(String[] args) {
// 创建两个异步任务
CompletableFuture future1 = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(1000);


} catch (InterruptedException e) {
e.printStackTrace();
}
return "Task 1 completed!";
});

CompletableFuture future2 = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Task 2 completed!";
});

// 组合两个任务的结果
CompletableFuture combinedFuture = future1.thenCombine(future2, (result1, result2) -> {
return result1 + " and " + result2;
});

// 处理组合结果
combinedFuture.thenAccept(result -> System.out.println("Combined Result: " + result));

try {
// 主线程等待异步任务完成
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

最后说一句(求关注!别白嫖！)

如果这篇文章对您有所帮助，或者有所启发的话，求一键三连：点赞、转发、在看。

关注公众号：woniuxgg，在公众号中回复：笔记  就可以获得蜗牛为你精心准备的java实战语雀笔记，回复面试、开发手册、有超赞的粉丝福利！