一文教你如何判斷Java代碼中異步操作是否完成

更新時間：2024年02月27日 09:46:52 作者：皮牙子抓飯

在許多應用程序中,我們經(jīng)常使用異步操作來提高性能和響應度,這篇文章主要介紹了幾種常見的方法來判斷Java代碼中異步操作是否完成,希望對大家有所幫助

在許多應用程序中，我們經(jīng)常使用異步操作來提高性能和響應度。在Java中，我們可以使用多線程或者異步任務來執(zhí)行耗時操作，并且在后臺處理過程完成后獲取結果。但是，在使用異步操作時，我們通常需要知道異步任務何時完成，以便進行下一步的操作。本篇文章將介紹幾種常見的方法來判斷Java代碼中異步操作是否完成。

1. 使用Future和Callable

Java中的Future接口定義了一種方式來表示異步操作的未來結果。我們可以使用Callable接口來定義異步任務，它返回一個Future對象，我們可以利用Future對象的方法來檢查任務是否完成。下面是一個例子：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class AsyncDemo {
    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        // 定義異步任務
        Callable<String> asyncTask = () -> {
            Thread.sleep(2000); // 模擬耗時操作
            return "Async task completed";
        };
        // 提交異步任務
        Future<String> future = executorService.submit(asyncTask);
        // 判斷任務是否完成
        while (!future.isDone()) {
            System.out.println("Task not done yet...");
            Thread.sleep(500);
        }
        // 獲取結果
        String result = future.get();
        System.out.println(result);
        // 關閉線程池
        executorService.shutdown();
    }
}

在上面的代碼中，我們創(chuàng)建了一個單線程的ExecutorService來執(zhí)行異步任務。我們使用submit方法提交異步任務，并得到一個Future對象。然后，我們可以使用isDone()方法來判斷任務是否完成，如果任務沒有完成，則等待片刻后再次檢查。一旦任務完成，我們可以使用get()方法獲取任務的結果。

2. 使用CompletableFuture

自Java 8起，Java提供了CompletableFuture類來更加方便地處理異步操作。CompletableFuture是Future的一個實現(xiàn)，同時也支持對未來結果的處理和組合。下面是一個例子：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
public class AsyncDemo {
    public static void main(String[] args) throws Exception {
        // 定義異步任務
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(2); // 模擬耗時操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Async task completed";
        });
        // 判斷任務是否完成
        while (!future.isDone()) {
            System.out.println("Task not done yet...");
            TimeUnit.MILLISECONDS.sleep(500);
        }
        // 獲取結果
        String result = future.get();
        System.out.println(result);
    }
}

在上述代碼中，我們使用supplyAsync方法創(chuàng)建了一個CompletableFuture對象，并定義了異步任務。然后，我們可以使用isDone()方法來判斷任務是否完成。通過調用get()方法可以獲取最終的結果。

當涉及到實際應用場景時，異步操作的一個常見用例是在Web應用中執(zhí)行并行的HTTP請求以提高性能。以下是一個示例代碼，展示了如何使用異步操作來執(zhí)行多個HTTP請求，并在所有請求完成后進行處理。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
public class AsyncHttpExample {
    public static void main(String[] args) throws Exception {
        List<Future<String>> futures = new ArrayList<>();
        
        ExecutorService executor = Executors.newFixedThreadPool(5);
        
        List<String> urls = List.of(
                "https://www.example.com/api1",
                "https://www.example.com/api2",
                "https://www.example.com/api3"
        );
        
        for (String url : urls) {
            Callable<String> task = () -> {
                return performRequest(url);
            };
            
            Future<String> future = executor.submit(task);
            futures.add(future);
        }
        
        executor.shutdown();
        
        for (Future<String> future : futures) {
            try {
                String result = future.get();
                System.out.println("Received response: " + result);
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
    
    private static String performRequest(String url) throws IOException {
        HttpURLConnection connection = null;
        BufferedReader reader = null;
        StringBuilder response = new StringBuilder();
        
        try {
            URL requestUrl = new URL(url);
            connection = (HttpURLConnection) requestUrl.openConnection();
            connection.setRequestMethod("GET");
            
            reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String line;
            
            while ((line = reader.readLine()) != null) {
                response.append(line);
            }
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
            
            if (reader != null) {
                reader.close();
            }
        }
        
        return response.toString();
    }
}

在這個示例中，我們創(chuàng)建了一個固定大小的線程池，并為每個URL創(chuàng)建了一個異步任務。每個任務在自己的線程中執(zhí)行HTTP請求，并返回響應結果。我們使用Future來跟蹤每個任務的執(zhí)行狀態(tài)和結果。一旦所有任務都被提交，我們調用shutdown()方法關閉線程池，然后通過迭代每個Future對象，使用get()方法獲取任務的結果。最后，我們可以根據(jù)需要對結果進行進一步處理，這里只是簡單地打印出每個請求的響應。

java.util.concurrent.Callable 是 Java 并發(fā)編程中的一個接口，它表示一個可調用的任務，可以在計算中返回一個值。與 Runnable 接口不同，Callable 接口的 call() 方法可以返回一個結果，并且可以在執(zhí)行過程中拋出受檢異常。 Callable 接口定義了以下方法：

V call() throws Exception：執(zhí)行任務并返回結果?？梢話伋鍪軝z異常。
boolean equals(Object obj)：比較該 Callable 與指定對象是否相等。
default <U> Callable<U> compose(Function<? super V, ? extends U> var1)：將該 Callable 的結果應用于給定函數(shù)，并返回 Callable。
default <V2> Callable<V2> andThen(Function<? super V, ? extends V2> var1)：將給定函數(shù)應用于該 Callable 的結果，并返回新的 Callable。
default Predicate<V> isEqual(Object var1)：返回謂詞，用于判斷對象是否與這個 Callable 的結果相等。
default Supplier<V> toSupplier()：返回將該 Callable 的結果作為值的供應商。在實際應用中，Callable 接口常常與 ExecutorService 結合使用，通過將 Callable 對象提交給線程池來執(zhí)行。線程池會返回一個 Future 對象，用于跟蹤任務的執(zhí)行狀態(tài)和獲取結果。以下是一個示例代碼，展示了如何使用 Callable 接口：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class CallableExample {
    public static void main(String[] args) throws Exception {
        Callable<Integer> task = () -> {
            int sum = 0;
            for (int i = 1; i <= 100; i++) {
                sum += i;
            }
            return sum;
        };
        
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<Integer> future = executor.submit(task);
        
        // 可以在此處執(zhí)行其他任務
        
        Integer result = future.get(); // 獲取任務的結果，會阻塞直到任務完成
        System.out.println("Sum: " + result);
        
        executor.shutdown();
    }
}

在上述示例中，我們創(chuàng)建了一個實現(xiàn)了 Callable 接口的任務，并將其提交給一個單線程的線程池來執(zhí)行。我們通過 Future 對象來獲取 Callable 任務的執(zhí)行結果，其中 get() 方法會阻塞當前線程，直到任務完成并返回結果。