Java使用線程實現(xiàn)異步運行的方法

更新時間：2024年07月08日 09:41:44 作者：TS86

在Java中,實現(xiàn)異步運行的一個常用方式是使用Thread類,這篇文章主要介紹了Java使用線程實現(xiàn)異步運行,需要的朋友可以參考下

1. 使用Thread類實現(xiàn)異步運行

假設我們有一個任務，該任務需要模擬一個耗時操作，比如從網(wǎng)絡下載一個大文件。我們將使用Thread類來異步執(zhí)行這個任務，以便主程序可以繼續(xù)執(zhí)行其他任務，而不需要等待下載完成。

public class AsyncTaskExample {  
    // 模擬耗時任務的Runnable實現(xiàn)  
    static class LongRunningTask implements Runnable {  
        @Override  
        public void run() {  
            // 模擬耗時操作，例如網(wǎng)絡請求或文件處理  
            try {  
                // 使用Thread.sleep來模擬耗時操作  
                System.out.println("開始執(zhí)行耗時任務...");  
                Thread.sleep(5000); // 假設這個任務是耗時5秒的  
                System.out.println("耗時任務完成！");  
            } catch (InterruptedException e) {  
                Thread.currentThread().interrupt(); // 保持中斷狀態(tài)  
                System.out.println("任務被中斷！");  
            }  
        }  
    }  
    public static void main(String[] args) {  
        // 創(chuàng)建Runnable實例  
        Runnable task = new LongRunningTask();  
        // 創(chuàng)建Thread實例，并將Runnable作為任務傳遞  
        Thread thread = new Thread(task);  
        // 啟動線程  
        System.out.println("啟動異步任務...");  
        long startTime = System.currentTimeMillis(); // 記錄開始時間  
        thread.start(); // 啟動線程，注意start()方法調(diào)用后，線程將獨立執(zhí)行  
        // 主線程繼續(xù)執(zhí)行，不等待異步任務完成  
        for (int i = 0; i < 5; i++) {  
            System.out.println("主線程正在執(zhí)行其他任務... " + i);  
            try {  
                Thread.sleep(1000); // 模擬主線程正在執(zhí)行其他任務  
            } catch (InterruptedException e) {  
                Thread.currentThread().interrupt();  
            }  
        }  
        long endTime = System.currentTimeMillis(); // 記錄結束時間  
        System.out.println("主線程結束，耗時：" + (endTime - startTime) + "毫秒");  
        // 注意：這里的代碼不會等待異步線程完成，如果你需要等待異步線程完成，可以調(diào)用thread.join();  
        // 但是在這個例子中，我們不會這樣做，以展示異步執(zhí)行的特性  
    }  
}

代碼解釋：

（1）LongRunningTask：這是一個實現(xiàn)了Runnable接口的類，用于封裝耗時的任務。在這個例子中，我們使用Thread.sleep(5000)來模擬耗時操作。

（2）main方法：

創(chuàng)建一個LongRunningTask的實例。
使用這個實例作為參數(shù)創(chuàng)建一個Thread對象。
調(diào)用thread.start()來啟動線程，這將導致LongRunningTask的run方法在新線程中異步執(zhí)行。
在主線程中，我們使用一個循環(huán)來模擬主線程正在執(zhí)行的其他任務，并使用Thread.sleep(1000)來模擬這些任務的耗時。
注意到主線程不會等待異步線程完成，它將繼續(xù)執(zhí)行直到循環(huán)結束。

注意事項：

異步執(zhí)行意味著主線程和異步線程將并行執(zhí)行，互不干擾。
如果需要主線程等待異步線程完成，可以調(diào)用thread.join()。但在上面的示例中，我們沒有這樣做以展示異步執(zhí)行的特性。
在處理多線程時，要特別注意線程安全和資源同步問題。上面的示例較為簡單，沒有涉及到這些高級概念。但在實際應用中，這些問題可能非常重要。

除了直接使用Thread類之外，Java還提供了其他幾種實現(xiàn)異步運行的方法。以下是一些常用的方法，并給出詳細的代碼示例。

2. 使用ExecutorService

ExecutorService是java.util.concurrent包中的一個接口，它提供了一種更靈活的方式來管理線程池中的線程。使用ExecutorService可以方便地控制線程的數(shù)量、執(zhí)行異步任務，并獲取任務執(zhí)行的結果。

import java.util.concurrent.Callable;  
import java.util.concurrent.ExecutionException;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.Future;  
public class ExecutorServiceExample {  
    // 模擬耗時任務的Callable實現(xiàn)  
    static class LongRunningTask implements Callable<String> {  
        @Override  
        public String call() throws Exception {  
            // 模擬耗時操作  
            Thread.sleep(5000);  
            return "任務完成";  
        }  
    }  
    public static void main(String[] args) {  
        // 創(chuàng)建一個固定大小的線程池  
        ExecutorService executor = Executors.newFixedThreadPool(2);  
        // 提交任務并獲取Future對象  
        Future<String> future = executor.submit(new LongRunningTask());  
        // 主線程繼續(xù)執(zhí)行其他任務  
        System.out.println("主線程正在執(zhí)行其他任務...");  
        try {  
            // 如果需要，可以等待異步任務完成并獲取結果  
            String result = future.get(); // 這將會阻塞，直到任務完成  
            System.out.println("異步任務結果: " + result);  
        } catch (InterruptedException | ExecutionException e) {  
            e.printStackTrace();  
        }  
        // 關閉線程池（注意：這不會立即停止正在執(zhí)行的任務）  
        executor.shutdown();  
        // 如果你想立即停止所有正在執(zhí)行的任務，可以使用shutdownNow()，但這通常不是推薦的做法  
        // executor.shutdownNow();  
    }  
}

3. 使用CompletableFuture

CompletableFuture是Java 8引入的一個類，它實現(xiàn)了Future和CompletionStage接口，提供了更豐富的異步編程能力。CompletableFuture可以顯式地處理異步操作的結果，并且可以鏈式調(diào)用其他異步操作。

import java.util.concurrent.CompletableFuture;  
public class CompletableFutureExample {  
    // 模擬耗時任務的Runnable  
    static Runnable longRunningTask = () -> {  
        try {  
            // 模擬耗時操作  
            Thread.sleep(5000);  
            System.out.println("耗時任務完成！");  
        } catch (InterruptedException e) {  
            Thread.currentThread().interrupt();  
        }  
    };  
    public static void main(String[] args) {  
        // 使用runAsync方法提交一個異步任務，但不關心其結果  
        CompletableFuture.runAsync(longRunningTask);  
        // 如果你想處理異步任務的結果，可以使用supplyAsync（返回結果）或thenApply等方法  
        // 例如：  
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {  
            // 模擬耗時操作并返回結果  
            try {  
                Thread.sleep(3000);  
            } catch (InterruptedException e) {  
                Thread.currentThread().interrupt();  
            }  
            return "異步任務結果";  
        });  
        // 鏈式調(diào)用處理結果  
        future.thenAccept(result -> System.out.println("處理結果: " + result));  
        // 主線程繼續(xù)執(zhí)行其他任務  
        System.out.println("主線程正在執(zhí)行其他任務...");  
        // 注意：main方法會立即結束，因為CompletableFuture的操作是異步的。  
        // 如果需要等待異步任務完成，可以調(diào)用future.join()（但注意，CompletableFuture沒有join方法，這里只是示意）  
        // 或者使用future.get()，但這會阻塞當前線程直到任務完成。  
        // 為了演示，我們可以簡單地讓主線程等待一段時間  
        try {  
            Thread.sleep(6000); // 等待足夠長的時間以確保異步任務完成  
        } catch (InterruptedException e) {  
            Thread.currentThread().interrupt();  
        }  
    }  
}  
// 注意：上面的CompletableFuture示例中，我使用了Thread.sleep來模擬等待異步任務完成，  
// 這在實際應用中通常不是最佳實踐。在實際應用中，你可能需要更復雜的邏輯來處理異步任務的結果。

請注意，CompletableFuture的get()方法會阻塞當前線程直到異步任務完成，這與Future.get()的行為相同。

4. 如何在Java中實現(xiàn)異步運行

在Java中實現(xiàn)異步運行，通常指的是在不阻塞當前線程的情況下執(zhí)行耗時操作或長時間運行的任務。Java提供了多種機制來實現(xiàn)異步編程，包括使用ExecutorService、CompletableFuture、Future接口，以及Java 9及以后版本中引入的Flow.Publisher和Flow.Subscriber（Reactive Streams API）等。以下是幾種常見的實現(xiàn)異步運行的方法：

4.1 使用`ExecutorService`

ExecutorService是java.util.concurrent包中的一個接口，它提供了一種管理線程池的方法，允許我們提交任務給線程池中的線程執(zhí)行，而不需要顯式地創(chuàng)建和管理線程。

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
public class AsyncExecutorService {  
    public static void main(String[] args) {  
        // 創(chuàng)建一個固定大小的線程池  
        ExecutorService executor = Executors.newFixedThreadPool(2);  
        // 提交任務給線程池執(zhí)行  
        executor.submit(() -> {  
            // 耗時任務  
            System.out.println("異步任務開始執(zhí)行...");  
            try {  
                Thread.sleep(5000); // 模擬耗時操作  
            } catch (InterruptedException e) {  
                Thread.currentThread().interrupt();  
            }  
            System.out.println("異步任務執(zhí)行完成！");  
        });  
        // 主線程繼續(xù)執(zhí)行其他任務  
        System.out.println("主線程繼續(xù)執(zhí)行...");  
        // 注意：通常應該關閉ExecutorService，但這里為了簡化示例沒有包含關閉代碼  
        // executor.shutdown();  
    }  
}

4.2 使用CompletableFuture

CompletableFuture是Java 8引入的一個類，用于編寫異步代碼。它實現(xiàn)了Future和CompletionStage接口，提供了豐富的API來處理異步編程中的結果。

import java.util.concurrent.CompletableFuture;  
public class AsyncCompletableFuture {  
    public static void main(String[] args) {  
        // 使用supplyAsync提交一個返回結果的異步任務  
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {  
            // 耗時任務  
            try {  
                Thread.sleep(5000); // 模擬耗時操作  
            } catch (InterruptedException e) {  
                Thread.currentThread().interrupt();  
            }  
            return "異步任務結果";  
        });  
        // 異步處理結果  
        future.thenAccept(result -> System.out.println("處理結果: " + result));  
        // 主線程繼續(xù)執(zhí)行其他任務  
        System.out.println("主線程繼續(xù)執(zhí)行...");  
        // 注意：通常不需要顯式等待CompletableFuture完成，因為它會自動在后臺執(zhí)行  
        // 但如果你需要等待結果，可以使用future.join()（注意：CompletableFuture沒有join方法，這里只是示意）  
        // 或者使用future.get()，但這會阻塞當前線程  
    }  
}  
// 注意：CompletableFuture沒有join方法，但你可以使用future.get()來阻塞等待結果，  
// 或者使用future.thenRun(Runnable)等方法來在任務完成后執(zhí)行某些操作，而不會阻塞當前線程。

4.3 使用Future

雖然Future接口本身不提供直接創(chuàng)建異步任務的方法，但它通常與ExecutorService一起使用來接收異步執(zhí)行的結果。

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.Future;  
public class AsyncFuture {  
    public static void main(String[] args) throws Exception {  
        // 創(chuàng)建一個ExecutorService  
        ExecutorService executor = Executors.newSingleThreadExecutor();  
        // 提交任務并獲取Future對象  
        Future<String> future = executor.submit(() -> {  
            // 耗時任務  
            Thread.sleep(5000); // 模擬耗時操作  
            return "異步任務結果";  
        });  
        // 主線程繼續(xù)執(zhí)行其他任務  
        System.out.println("主線程繼續(xù)執(zhí)行...");  
        // 等待異步任務完成并獲取結果  
        // 注意：這會阻塞當前線程直到任務完成  
        String result = future.get();  
        System.out.println("異步任務結果: " + result);  
        // 關閉ExecutorService  
        executor.shutdown();  
    }  
}

4.4 總結

以上是在Java中實現(xiàn)異步運行的幾種常見方法。選擇哪種方法取決于我們的具體需求，比如是否需要處理異步結果、是否需要控制線程池的大小、是否偏好使用Java 8的lambda表達式等。在實際應用中，通常建議使用ExecutorService或CompletableFuture，因為它們提供了更靈活和強大的異步編程能力。

到此這篇關于Java使用線程實現(xiàn)異步運行的文章就介紹到這了,更多相關Java異步運行內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: