Java 8 - juc - CompletableFuture

我会带着你远行 2023-10-11 00:04 22阅读 0赞

CompletableFuture常用的一些方法及其作用：

使用thenApply方法对CompletableFuture的结果进行转换操作，并返回一个新的CompletableFuture。
    使用thenAccept方法对CompletableFuture的结果进行处理，并执行指定的操作。
    使用thenRun方法在CompletableFuture完成时执行指定的操作，不对结果进行处理。
    使用exceptionally方法处理CompletableFuture中的异常情况，并返回一个默认值。
    使用handle方法对CompletableFuture的结果或异常进行处理，并返回一个新的结果。

import java.util.concurrent.CompletableFuture;
    import java.util.concurrent.ExecutionException;
    
    public class CompletableFutureExample {
        
    
        public static void main(String[] args) {
        
            // 创建一个CompletableFuture实例，并使用supplyAsync方法异步执行一个任务
            CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
        
                // 模拟一个耗时的操作
                try {
        
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                return "Hello";
            });
    
            // thenApply：对任务结果进行转换
            CompletableFuture<Integer> transformed = future.thenApply(str -> {
        
                // 将结果转换为长度
                return str.length();
            });
    
            // thenAccept：对任务结果进行处理
            transformed.thenAccept(length -> {
        
                System.out.println("Length: " + length);
            });
    
            // thenRun：在任务完成后执行操作
            transformed.thenRun(() -> {
        
                System.out.println("Task completed");
            });
    
            // exceptionally：处理异常情况
            CompletableFuture<Integer> exceptionHandled = future.thenApply(str -> {
        
                // 模拟一个异常情况
                if (str.equals("Hello")) {
        
                    throw new IllegalArgumentException("Invalid argument");
                }
                return str.length();
            }).exceptionally(ex -> {
        
                System.out.println("Exception occurred: " + ex.getMessage());
                return -1;
            });
    
            // handle：对任务结果或异常进行处理
            CompletableFuture<Integer> handled = future.handle((result, ex) -> {
        
                if (ex != null) {
        
                    System.out.println("Exception occurred: " + ex.getMessage());
                    return -1;
                } else {
        
                    return result.length();
                }
            });
    
            try {
        
                // 等待任务完成并获取结果
                Integer length = transformed.get();
                System.out.println("Length: " + length);
    
                // 获取异常处理后的结果
                Integer handledResult = exceptionHandled.get();
                System.out.println("Handled Result: " + handledResult);
    
                // 获取handle处理后的结果
                Integer handleResult = handled.get();
                System.out.println("Handle Result: " + handleResult);
            } catch (InterruptedException | ExecutionException e) {
        
                e.printStackTrace();
            }
        }
    }