CompletableFuture 常用方法介绍

CompletableFuture 是 Java 8 引入的一个强大的异步编程工具类,它实现了 Future 和 CompletionStage 接口,提供了丰富的方法来处理异步任务的创建、组合、结果获取等操作。以下是对 CompletableFuture 基本异步方法的详细介绍:

1. 创建异步任务

runAsync(Runnable runnable)

  • 功能:以异步方式执行一个 Runnable 任务,不返回结果。默认使用 ForkJoinPool.commonPool() 线程池。
  • 示例代码

java

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture future = CompletableFuture.runAsync(() -> {
            System.out.println("Running task asynchronously...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Task completed.");
        });

        // 等待任务完成
        future.join();
    }
}
runAsync(Runnable runnable, Executor executor)

  • 功能:以异步方式执行一个 Runnable 任务,不返回结果,使用指定的线程池 executor
  • 示例代码

java

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CompletableFutureExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        CompletableFuture future = CompletableFuture.runAsync(() -> {
            System.out.println("Running task asynchronously with custom executor...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Task completed.");
        }, executor);

        // 等待任务完成
        future.join();
        executor.shutdown();
    }
}
supplyAsync(Supplier supplier)

  • 功能:以异步方式执行一个 Supplier 任务,返回一个 CompletableFuture 对象,该对象最终会包含 Supplier 的返回值。默认使用 ForkJoinPool.commonPool() 线程池。
  • 示例代码

java

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture future = CompletableFuture.supplyAsync(() -> {
            System.out.println("Running task asynchronously...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Task result";
        });

        // 获取任务结果
        String result = future.join();
        System.out.println("Result: " + result);
    }
}
supplyAsync(Supplier supplier, Executor executor)

  • 功能:以异步方式执行一个 Supplier 任务,返回一个 CompletableFuture 对象,该对象最终会包含 Supplier 的返回值,使用指定的线程池 executor
  • 示例代码

java

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CompletableFutureExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        CompletableFuture future = CompletableFuture.supplyAsync(() -> {
            System.out.println("Running task asynchronously with custom executor...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Task result";
        }, executor);

        // 获取任务结果
        String result = future.join();
        System.out.println("Result: " + result);
        executor.shutdown();
    }
}

2. 处理任务结果

thenApply(Function fn)

  • 功能:当 CompletableFuture 完成时,对其结果应用一个函数,并返回一个新的 CompletableFuture,该新 CompletableFuture 的结果是函数的返回值。
  • 示例代码

java

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture future = CompletableFuture.supplyAsync(() -> "Hello")
               .thenApply(s -> s + " World");

        String result = future.join();
        System.out.println(result); // 输出: Hello World
    }
}
thenAccept(Consumer action)

  • 功能:当 CompletableFuture 完成时,对其结果执行一个消费操作,不返回结果,返回的 CompletableFuture 类型为 CompletableFuture
  • 示例代码

java

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture future = CompletableFuture.supplyAsync(() -> "Hello")
               .thenAccept(s -> System.out.println(s));

        future.join(); // 输出: Hello
    }
}
thenRun(Runnable action)

  • 功能:当 CompletableFuture 完成时,执行一个 Runnable 任务,不关心原任务的结果,返回的 CompletableFuture 类型为 CompletableFuture
  • 示例代码

java

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture future = CompletableFuture.supplyAsync(() -> "Hello")
               .thenRun(() -> System.out.println("Task completed"));

        future.join(); // 输出: Task completed
    }
}

3. 组合多个 CompletableFuture

thenCompose(Function> fn)

  • 功能:当 CompletableFuture 完成时,将其结果传递给一个函数,该函数返回另一个 CompletionStage,最终返回一个新的 CompletableFuture,该新 CompletableFuture 的结果是嵌套 CompletionStage 的结果。
  • 示例代码

java

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture future = CompletableFuture.supplyAsync(() -> "Hello")
               .thenCompose(s -> CompletableFuture.supplyAsync(() -> s + " World"));

        String result = future.join();
        System.out.println(result); // 输出: Hello World
    }
}
thenCombine(CompletionStage other, BiFunction fn)

  • 功能:当当前 CompletableFuture 和另一个 CompletionStage 都完成时,将它们的结果传递给一个二元函数,并返回一个新的 CompletableFuture,该新 CompletableFuture 的结果是二元函数的返回值。
  • 示例代码

java

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture future1 = CompletableFuture.supplyAsync(() -> "Hello");
        CompletableFuture future2 = CompletableFuture.supplyAsync(() -> " World");

        CompletableFuture combinedFuture = future1.thenCombine(future2, (s1, s2) -> s1 + s2);

        String result = combinedFuture.join();
        System.out.println(result); // 输出: Hello World
    }
}
allOf(CompletableFuture... cfs)

  • 功能:返回一个新的 CompletableFuture,当所有给定的 CompletableFuture 都完成时,该新 CompletableFuture 完成。它不返回任何结果,类型为 CompletableFuture
  • 示例代码

java

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture future1 = CompletableFuture.supplyAsync(() -> "Result 1");
        CompletableFuture future2 = CompletableFuture.supplyAsync(() -> "Result 2");

        CompletableFuture allFutures = CompletableFuture.allOf(future1, future2);

        allFutures.join();
        System.out.println("All tasks completed");
    }
}
anyOf(CompletableFuture... cfs)

  • 功能:返回一个新的 CompletableFuture,当任何一个给定的 CompletableFuture 完成时,该新 CompletableFuture 完成,其结果是第一个完成的 CompletableFuture 的结果。
  • 示例代码

java

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture future1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Result 1";
        });
        CompletableFuture future2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Result 2";
        });

        CompletableFuture anyFuture = CompletableFuture.anyOf(future1, future2);

        Object result = anyFuture.join();
        System.out.println("First completed result: " + result); // 输出: Result 2
    }
}
 
  

4. 异常处理

exceptionally(Function fn)

  • 功能:当 CompletableFuture 出现异常时,将异常传递给一个函数,该函数返回一个默认值,最终返回一个新的 CompletableFuture,其结果是函数的返回值。
  • 示例代码

java

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture future = CompletableFuture.supplyAsync(() -> {
            throw new RuntimeException("Something went wrong");
        }).exceptionally(ex -> {
            System.out.println("Exception caught: " + ex.getMessage());
            return "Default result";
        });

        String result = future.join();
        System.out.println(result); // 输出: Default result
    }
}
handle(BiFunction fn)

  • 功能:无论 CompletableFuture 是否完成或出现异常,都将结果(或 null,如果出现异常)和异常(或 null,如果没有异常)传递给一个二元函数,并返回一个新的 CompletableFuture,其结果是二元函数的返回值。
  • 示例代码

java

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture future = CompletableFuture.supplyAsync(() -> {
            throw new RuntimeException("Something went wrong");
        }).handle((result, ex) -> {
            if (ex != null) {
                System.out.println("Exception caught: " + ex.getMessage());
                return "Default result";
            }
            return result;
        });

        String result = future.join();
        System.out.println(result); // 输出: Default result
    }
}

以上就是 CompletableFuture 的一些基本异步方法的介绍,通过这些方法可以方便地进行异步编程和任务组合。

你可能感兴趣的:(java,分布式,spring,cloud)