public class AsyncTaskExample {  
    // 模擬耗時(shí)任務(wù)的Runnable實(shí)現(xiàn)  
    static class LongRunningTask implements Runnable {  
        @Override  
        public void run() {  
            // 模擬耗時(shí)操作，例如網(wǎng)絡(luò)請(qǐng)求或文件處理  
            try {  
                // 使用Thread.sleep來模擬耗時(shí)操作  
                System.out.println("開始執(zhí)行耗時(shí)任務(wù)...");  
                Thread.sleep(5000); // 假設(shè)這個(gè)任務(wù)是耗時(shí)5秒的  
                System.out.println("耗時(shí)任務(wù)完成！");  
            } catch (InterruptedException e) {  
                Thread.currentThread().interrupt(); // 保持中斷狀態(tài)  
                System.out.println("任務(wù)被中斷！");  
            }  
        }  
    }  
    public static void main(String[] args) {  
        // 創(chuàng)建Runnable實(shí)例  
        Runnable task = new LongRunningTask();  
        // 創(chuàng)建Thread實(shí)例，并將Runnable作為任務(wù)傳遞  
        Thread thread = new Thread(task);  
        // 啟動(dòng)線程  
        System.out.println("啟動(dòng)異步任務(wù)...");  
        long startTime = System.currentTimeMillis(); // 記錄開始時(shí)間  
        thread.start(); // 啟動(dòng)線程，注意start()方法調(diào)用后，線程將獨(dú)立執(zhí)行  
        // 主線程繼續(xù)執(zhí)行，不等待異步任務(wù)完成  
        for (int i = 0; i < 5; i++) {  
            System.out.println("主線程正在執(zhí)行其他任務(wù)... " + i);  
            try {  
                Thread.sleep(1000); // 模擬主線程正在執(zhí)行其他任務(wù)  
            } catch (InterruptedException e) {  
                Thread.currentThread().interrupt();  
            }  
        }  
        long endTime = System.currentTimeMillis(); // 記錄結(jié)束時(shí)間  
        System.out.println("主線程結(jié)束，耗時(shí)：" + (endTime - startTime) + "毫秒");  
        // 注意：這里的代碼不會(huì)等待異步線程完成，如果你需要等待異步線程完成，可以調(diào)用thread.join();  
        // 但是在這個(gè)例子中，我們不會(huì)這樣做，以展示異步執(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 {  
    // 模擬耗時(shí)任務(wù)的Callable實(shí)現(xiàn)  
    static class LongRunningTask implements Callable<String> {  
        @Override  
        public String call() throws Exception {  
            // 模擬耗時(shí)操作  
            Thread.sleep(5000);  
            return "任務(wù)完成";  
        }  
    }  
    public static void main(String[] args) {  
        // 創(chuàng)建一個(gè)固定大小的線程池  
        ExecutorService executor = Executors.newFixedThreadPool(2);  
        // 提交任務(wù)并獲取Future對(duì)象  
        Future<String> future = executor.submit(new LongRunningTask());  
        // 主線程繼續(xù)執(zhí)行其他任務(wù)  
        System.out.println("主線程正在執(zhí)行其他任務(wù)...");  
        try {  
            // 如果需要，可以等待異步任務(wù)完成并獲取結(jié)果  
            String result = future.get(); // 這將會(huì)阻塞，直到任務(wù)完成  
            System.out.println("異步任務(wù)結(jié)果: " + result);  
        } catch (InterruptedException | ExecutionException e) {  
            e.printStackTrace();  
        }  
        // 關(guān)閉線程池（注意：這不會(huì)立即停止正在執(zhí)行的任務(wù)）  
        executor.shutdown();  
        // 如果你想立即停止所有正在執(zhí)行的任務(wù)，可以使用shutdownNow()，但這通常不是推薦的做法  
        // executor.shutdownNow();  
    }  
}

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

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

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

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)建一個(gè)ExecutorService  
        ExecutorService executor = Executors.newSingleThreadExecutor();  
        // 提交任務(wù)并獲取Future對(duì)象  
        Future<String> future = executor.submit(() -> {  
            // 耗時(shí)任務(wù)  
            Thread.sleep(5000); // 模擬耗時(shí)操作  
            return "異步任務(wù)結(jié)果";  
        });  
        // 主線程繼續(xù)執(zhí)行其他任務(wù)  
        System.out.println("主線程繼續(xù)執(zhí)行...");  
        // 等待異步任務(wù)完成并獲取結(jié)果  
        // 注意：這會(huì)阻塞當(dāng)前線程直到任務(wù)完成  
        String result = future.get();  
        System.out.println("異步任務(wù)結(jié)果: " + result);  
        // 關(guān)閉ExecutorService  
        executor.shutdown();  
    }  
}