Java8 CompletableFuture异步编程解读

	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);  // 创建线程池
        
        callable<integer> task = () -> {
            thread.sleep(1000);
            return 42;
        };
        
        future<integer> result = executor.submit(task);  // 提交任务并获得 future 对象
        system.out.println("task result: " + result.get());  // 获取结果
        
        executor.shutdown();  // 关闭线程池
    }

    public static void main(string[] args) throws interruptedexception {
        executorservice executor = executors.newfixedthreadpool(2);  // 创建线程池
        
        runnable task = () -> {
            system.out.println(thread.currentthread().getname() + " is running...");
        };
        
        executor.execute(task);  // 提交任务
        
        executor.shutdown();  // 关闭线程池
    }

    public static void main(string[] args) throws interruptedexception {
        int totalthreads = 3;
        countdownlatch latch = new countdownlatch(totalthreads);  // 初始化计数器为3
        
        runnable task = () -> {
            try {
                thread.sleep(1000);
                system.out.println(thread.currentthread().getname() + " finished.");
            } catch (interruptedexception e) {
                e.printstacktrace();
            } finally {
                latch.countdown();  // 每个线程完成后减少计数器
            }
        };
        
        // 启动多个线程
        for (int i = 0; i < totalthreads; i++) {
            new thread(task).start();
        }
        
        latch.await();  // 等待计数器归零
        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();  // 等待其他线程到达屏障点
            } catch (exception e) {
                e.printstacktrace();
            }
        };
        
        // 启动多个线程
        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();  // 创建 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);  // 执行任务并获取结果
        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) {  // 基础情况
            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();  // 异步执行
            task2.fork();
            return task1.join() + task2.join();  // 合并结果
        }
    }
}

    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;
        });
        
        // 链式调用，处理结果
        completablefuture<integer> result = future.thenapplyasync(value -> value * 2);
        
        system.out.println("result: " + result.get());  // 输出结果
    }

    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;  // 返回结果
        });

        // 获取异步任务的结果
        integer result = future.get();  // 阻塞，直到任务完成
        system.out.println("result: " + result);
    }

    public static void main(string[] args) throws executionexception, interruptedexception {
        completablefuture<integer> future = completablefuture.supplyasync(() -> {
            return 42;  // 返回结果
        });

        // 链式调用，先处理结果，再转换
        completablefuture<integer> resultfuture = future
            .thenapply(value -> value * 2)  // 将值乘以2
            .thenapply(value -> value + 10);  // 再加10

        integer result = resultfuture.get();  // 获取最终结果
        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;
        });

        // 合并两个任务的结果
        completablefuture<integer> combinedfuture = future1
            .thencombine(future2, (result1, result2) -> result1 + result2);  // 将两个结果相加

        integer result = combinedfuture.get();  // 获取最终结果
        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();
            }
        });

        // 等待多个任务全部完成
        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 处理异常并提供默认值
        completablefuture<integer> resultfuture = future.exceptionally(ex -> {
            system.out.println("exception occurred: " + ex.getmessage());
            return -1;  // 返回默认值
        });

        integer result = resultfuture.get();  // 获取结果
        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;
            }
        });

        // 等待所有任务完成并合并结果
        completablefuture<integer> result = future1
            .thencombine(future2, (res1, res2) -> res1 + res2);  // 将两个结果相加

        system.out.println("combined result: " + result.get());  // 输出 3
    }

    public static void main(string[] args) throws executionexception, interruptedexception {
        completablefuture<integer> future = completablefuture.supplyasync(() -> 10);

        // 转换结果：将值乘以2
        completablefuture<integer> transformedfuture = future.thenapply(value -> value * 2);

        system.out.println("transformed result: " + transformedfuture.get());  // 输出 20
    }