public static void main(String[] args) {
        Thread thread = new Thread(() -> {
        	 System.out.println(Thread.currentThread().getName() + " is running...");
        });
        thread.start();
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executor = Executors.newFixedThreadPool(2);  // 創(chuàng)建線程池
        
        Callable<Integer> task = () -> {
            Thread.sleep(1000);
            return 42;
        };
        
        Future<Integer> result = executor.submit(task);  // 提交任務(wù)并獲得 Future 對(duì)象
        System.out.println("Task result: " + result.get());  // 獲取結(jié)果
        
        executor.shutdown();  // 關(guān)閉線程池
    }

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(2);  // 創(chuàng)建線程池
        
        Runnable task = () -> {
            System.out.println(Thread.currentThread().getName() + " is running...");
        };
        
        executor.execute(task);  // 提交任務(wù)
        
        executor.shutdown();  // 關(guān)閉線程池
    }

    public static void main(String[] args) throws InterruptedException {
        int totalThreads = 3;
        CountDownLatch latch = new CountDownLatch(totalThreads);  // 初始化計(jì)數(shù)器為3
        
        Runnable task = () -> {
            try {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + " finished.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                latch.countDown();  // 每個(gè)線程完成后減少計(jì)數(shù)器
            }
        };
        
        // 啟動(dòng)多個(gè)線程
        for (int i = 0; i < totalThreads; i++) {
            new Thread(task).start();
        }
        
        latch.await();  // 等待計(jì)數(shù)器歸零
        System.out.println("All tasks are finished.");
    }

    public static void main(String[] args) throws InterruptedException {
        int totalThreads = 3;
        CyclicBarrier barrier = new CyclicBarrier(totalThreads, () -> {
            System.out.println("All threads reached the barrier point, proceeding...");
        });
        
        Runnable task = () -> {
            try {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + " reached the barrier.");
                barrier.await();  // 等待其他線程到達(dá)屏障點(diǎn)
            } catch (Exception e) {
                e.printStackTrace();
            }
        };
        
        // 啟動(dòng)多個(gè)線程
        for (int i = 0; i < totalThreads; i++) {
            new Thread(task).start();
        }
    }

import java.util.concurrent.*;

public class ForkJoinPoolExample {
    public static void main(String[] args) {
        ForkJoinPool pool = new ForkJoinPool();  // 創(chuàng)建 ForkJoinPool
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8};
        RecursiveTask<Integer> task = new SumTask(array, 0, array.length);
        int result = pool.invoke(task);  // 執(zhí)行任務(wù)并獲取結(jié)果
        System.out.println("Sum is: " + result);
    }
}

class SumTask extends RecursiveTask<Integer> {
    private int[] array;
    private int start, end;
    
    public SumTask(int[] array, int start, int end) {
        this.array = array;
        this.start = start;
        this.end = end;
    }
    
    @Override
    protected Integer compute() {
        if (end - start <= 2) {  // 基礎(chǔ)情況
            int sum = 0;
            for (int i = start; i < end; i++) {
                sum += array[i];
            }
            return sum;
        } else {
            int mid = (start + end) / 2;
            SumTask task1 = new SumTask(array, start, mid);
            SumTask task2 = new SumTask(array, mid, end);
            task1.fork();  // 異步執(zhí)行
            task2.fork();
            return task1.join() + task2.join();  // 合并結(jié)果
        }
    }
}

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 42;
        });
        
        // 鏈?zhǔn)秸{(diào)用，處理結(jié)果
        CompletableFuture<Integer> result = future.thenApplyAsync(value -> value * 2);
        
        System.out.println("Result: " + result.get());  // 輸出結(jié)果
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 帶返回值的異步任務(wù)
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);  // 模擬耗時(shí)任務(wù)
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 42;  // 返回結(jié)果
        });

        // 獲取異步任務(wù)的結(jié)果
        Integer result = future.get();  // 阻塞，直到任務(wù)完成
        System.out.println("Result: " + result);
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            return 42;  // 返回結(jié)果
        });

        // 鏈?zhǔn)秸{(diào)用，先處理結(jié)果，再轉(zhuǎn)換
        CompletableFuture<Integer> resultFuture = future
            .thenApply(value -> value * 2)  // 將值乘以2
            .thenApply(value -> value + 10);  // 再加10

        Integer result = resultFuture.get();  // 獲取最終結(jié)果
        System.out.println("Final Result: " + result);  // 輸出 94
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            return 10;
        });

        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            return 20;
        });

        // 合并兩個(gè)任務(wù)的結(jié)果
        CompletableFuture<Integer> combinedFuture = future1
            .thenCombine(future2, (result1, result2) -> result1 + result2);  // 將兩個(gè)結(jié)果相加

        Integer result = combinedFuture.get();  // 獲取最終結(jié)果
        System.out.println("Combined Result: " + result);  // 輸出 30
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
            try {
                Thread.sleep(1000);
                System.out.println("Task 1 completed");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
            try {
                Thread.sleep(1500);
                System.out.println("Task 2 completed");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // 等待多個(gè)任務(wù)全部完成
        CompletableFuture.allOf(future1, future2).join();

        System.out.println("All tasks are completed.");
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            if (true) {
                throw new RuntimeException("Something went wrong!");
            }
            return 42;
        });

        // 使用 exceptionally 處理異常并提供默認(rèn)值
        CompletableFuture<Integer> resultFuture = future.exceptionally(ex -> {
            System.out.println("Exception occurred: " + ex.getMessage());
            return -1;  // 返回默認(rèn)值
        });

        Integer result = resultFuture.get();  // 獲取結(jié)果
        System.out.println("Result: " + result);  // 輸出 -1
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
                return 1;
            } catch (InterruptedException e) {
                return 0;
            }
        });

        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(500);
                return 2;
            } catch (InterruptedException e) {
                return 0;
            }
        });

        // 等待所有任務(wù)完成并合并結(jié)果
        CompletableFuture<Integer> result = future1
            .thenCombine(future2, (res1, res2) -> res1 + res2);  // 將兩個(gè)結(jié)果相加

        System.out.println("Combined result: " + result.get());  // 輸出 3
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 10);

        // 轉(zhuǎn)換結(jié)果：將值乘以2
        CompletableFuture<Integer> transformedFuture = future.thenApply(value -> value * 2);

        System.out.println("Transformed Result: " + transformedFuture.get());  // 輸出 20
    }