import java.util.concurrent.CompletableFuture;
public class ThenComposeDemo {
    // 模擬：查用戶地址
    public static CompletableFuture<String> getAddress(String username) {
        return CompletableFuture.supplyAsync(() -> {
            try { Thread.sleep(800); } catch (InterruptedException e) { e.printStackTrace(); }
            return username + "的地址是：北京市海淀區(qū)";
        });
    }
    // 模擬：根據(jù)地址查天氣
    public static CompletableFuture<String> getWeather(String address) {
        return CompletableFuture.supplyAsync(() -> {
            try { Thread.sleep(600); } catch (InterruptedException e) { e.printStackTrace(); }
            return address + "，今天天氣：晴，25℃";
        });
    }
    public static void main(String[] args) throws Exception {
        // 組合兩個依賴任務(wù)
        CompletableFuture<String> result = CompletableFuture.supplyAsync(() -> "小明")
                .thenCompose(username -> getAddress(username)) // 先查地址
                .thenCompose(address -> getWeather(address)); // 再查天氣
        System.out.println(result.get());
    }
}

import java.util.concurrent.CompletableFuture;
public class ThenCombineDemo {
    // 查價格
    public static CompletableFuture<Double> getPrice(String product) {
        return CompletableFuture.supplyAsync(() -> {
            try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println(product + "的價格是：99.9元");
            return 99.9;
        });
    }
    // 查庫存
    public static CompletableFuture<Integer> getStock(String product) {
        return CompletableFuture.supplyAsync(() -> {
            try { Thread.sleep(800); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println(product + "的庫存是：5件");
            return 5;
        });
    }
    public static void main(String[] args) throws Exception {
        String product = "Java編程思想";
        // 并行執(zhí)行兩個任務(wù)，然后合并結(jié)果
        CompletableFuture<Double> total = getPrice(product)
                .thenCombine(getStock(product), (price, stock) -> price * stock);
        System.out.println("總價：" + total.get() + "元");
    }
}

package com.itheima.future;
import java.util.concurrent.CompletableFuture;
public class AllOfDemo {
    public static void main(String[] args) throws Exception {
        //計(jì)時開始
        long start = System.currentTimeMillis();
        // 3個下載任務(wù)
        CompletableFuture<Void> download1 = CompletableFuture.runAsync(() -> {
            try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("文件1下載完成");
        });
        CompletableFuture<Void> download2 = CompletableFuture.runAsync(() -> {
            try { Thread.sleep(1500); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("文件2下載完成");
        });
        CompletableFuture<Void> download3 = CompletableFuture.runAsync(() -> {
            try { Thread.sleep(800); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("文件3下載完成");
        });
        // 等待所有任務(wù)完成
        CompletableFuture.allOf(download1, download2, download3).get();
        System.out.println("所有文件下載完成，開始打包...");
        System.out.println("打包完成，耗時：" + (System.currentTimeMillis() - start) + "毫秒");
    }
}

import java.util.concurrent.CompletableFuture;
public class AnyOfDemo {
    public static void main(String[] args) throws Exception {
        // 3個查詢?nèi)蝿?wù)（不同數(shù)據(jù)源）
        CompletableFuture<String> fromCache = CompletableFuture.supplyAsync(() -> {
            try { Thread.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); }
            return "從緩存查到數(shù)據(jù)：Java入門";
        });
        CompletableFuture<String> fromDb = CompletableFuture.supplyAsync(() -> {
            try { Thread.sleep(800); } catch (InterruptedException e) { e.printStackTrace(); }
            return "從數(shù)據(jù)庫查到數(shù)據(jù)：Java入門";
        });
        CompletableFuture<String> fromApi = CompletableFuture.supplyAsync(() -> {
            try { Thread.sleep(1200); } catch (InterruptedException e) { e.printStackTrace(); }
            return "從API查到數(shù)據(jù)：Java入門";
        });
        // 只要有一個任務(wù)完成就返回
        CompletableFuture<Object> result = CompletableFuture.anyOf(fromCache, fromDb, fromApi);
        System.out.println("最快的結(jié)果：" + result.get());
    }
}

import java.util.concurrent.CompletableFuture;
public class ExceptionDemo1 {
    public static void main(String[] args) throws Exception {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            // 模擬任務(wù)失敗
            if (true) {
                throw new RuntimeException("查詢失?。簲?shù)據(jù)庫連接超時");
            }
            return 100;
        }).exceptionally(ex -> {
            // 捕獲異常，返回默認(rèn)值
            System.out.println("出錯了：" + ex.getMessage());
            return 0; // 默認(rèn)值
        });
        System.out.println("最終結(jié)果：" + future.get()); // 輸出 0
    }
}

import java.util.concurrent.CompletableFuture;
public class ExceptionDemo2 {
    public static void main(String[] args) throws Exception {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 這里可以故意拋出異常測試
            return "正常結(jié)果";
        }).handle((result, ex) -> {
            if (ex != null) {
                return "處理異常：" + ex.getMessage();
            } else {
                return "處理成功：" + result;
            }
        });
        System.out.println(future.get()); // 輸出 處理成功：正常結(jié)果
    }
}

// 使用默認(rèn)線程池
CompletableFuture.supplyAsync(() -> {
    // 任務(wù)邏輯
    return "result";
});

package com.itheima.future;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
public class CustomThreadPoolDemo {
    // 自定義線程池(這里我暫時使用線程池包里的線程池，一般情況下要使用自定義線程池ThreadPoolExecutor)
    private static final ExecutorService customExecutor = Executors.newFixedThreadPool(10);
    public static void main(String[] args) {
        // 使用自定義線程池
        CompletableFuture.supplyAsync(() -> {
            System.out.println("任務(wù)在自定義線程池執(zhí)行：" + Thread.currentThread().getName());
            return "處理完成";
        }, customExecutor)
        .thenAccept(result -> {
            System.out.println("結(jié)果：" + result);
        });
        // 記得在程序結(jié)束時關(guān)閉線程池
        customExecutor.shutdown();
    }
}

ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(() -> {
    Thread.sleep(1000);
    return "任務(wù)結(jié)果";
});
// 必須阻塞等待結(jié)果
String result = future.get();
// 處理結(jié)果
System.out.println("處理：" + result);
executor.shutdown();

CompletableFuture.supplyAsync(() -> {
    try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }
    return "任務(wù)結(jié)果";
}).thenApply(result -> {
    return "處理后：" + result;
}).thenAccept(processedResult -> {
    System.out.println(processedResult);
});

ExecutorService executor = Executors.newSingleThreadExecutor();
Future<Integer> future = executor.submit(() -> {
    if (true) {
        throw new RuntimeException("計(jì)算失敗");
    }
    return 100;
});
try {
    Integer result = future.get(); // 異常會在這里拋出
} catch (Exception e) {
    // 處理異常
    e.printStackTrace();
}
executor.shutdown();

CompletableFuture.supplyAsync(() -> {
    if (true) {
        throw new RuntimeException("計(jì)算失敗");
    }
    return 100;
}).exceptionally(ex -> {
    System.out.println("捕獲異常：" + ex.getMessage());
    return 0; // 返回默認(rèn)值
}).thenAccept(result -> {
    System.out.println("結(jié)果：" + result); // 輸出0
});