springboot CompletableFuture asynchronous thread pool detailed explanation

//You can get the return value and pass it into a custom thread poolpublic static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)
//No return value, can be passed into a custom thread poolpublic static CompletableFuture<Void> runAsync(Runnable runnable)
public static CompletableFuture<Void> runAsync(Runnable runnable,Executor executor)

public static ExecutorService service = (10);
  //No return value        (()->{
            ("Async task was successfully completed");
        },service);
        //Empty parameter only returns value        CompletableFuture<String> stringCompletableFuture = (() -> {
            return "Return Value";
        }, service);

//The previous task is completed and the previous task is used in the same threadpublic CompletableFuture<T> whenComplete(BiConsumer<? super T, ? super Throwable> action);
//Leave it to the thread pool to restart a threadpublic CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action);
//After the task is completed (only perceived)public CompletableFuture<T> whenComplete(BiConsumer<? super T, ? super Throwable> action);
//Responsive exceptions at the same time modify the return valuepublic CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn);

 CompletableFuture<Integer> future = (() -> {
            return 10;
        }, service).whenComplete((res,excption)->{
            //Although you can get exception message, you cannot modify and return result            ("Async task was successfully completed"+res+"Or exception:"+excption);
        }).exceptionally(throwable ->{
            // Handle exceptions and can modify data return value            return 0;
       });

//Execute with the previous task using the same threadpublic <U> CompletableFuture<U> handle(BiFunction<? super T, Throwable, ? extends U> fn)
//The default thread pool enables thread executionpublic <U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn)
//Specify your own thread pool to enable thread executionpublic <U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn, Executor executor)

       //The processing after the method execution is completed is successful or failed        CompletableFuture<Integer> future = (() -> {
            return 10;
        }, service).handle((res,thr)->{
            //No exceptions appear, of course, you can not write them here for concealment           if(res!=null){
               return 0;
           }
           //Exception occurred           if(thr!=null){
               return 1;
           }
           return 0;
        });

//A-->B-->C Perceive the previous result and return the last resultpublic <U> CompletableFuture<U> thenApply(Function<? super T,? extends U> fn)
public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn)
public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn,Executor executor)

//B can sense the return value of Apublic CompletableFuture<Void> thenAccept(Consumer<? super T> action)
public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action) 
public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action,
                                                   Executor executor)
//A->After completing (Async starts a new thread, but does not have the same thread as A) cannot sense the execution result of the previous steppublic CompletableFuture<Void> thenRun(Runnable action) 
public CompletableFuture<Void> thenRunAsync(Runnable action) 
public CompletableFuture<Void> thenRunAsync(Runnable action, Executor executor) 

CompletableFuture<Void> voidCompletableFuture = (() -> {
            //Task A            return 10;
        }, service).thenRunAsync(() -> {
            //The result of task A cannot be sensed        },service);

CompletableFuture<Void> voidCompletableFuture = (() -> {
            //Task A            return 10;
        }, service).thenAcceptAsync((res) -> {
            //The result of task A can be sensed, but the data cannot be returned            int i = res / 2;
        },service);

CompletableFuture<Integer> future = (() -> {
            //Task A            return 10;
        }, service).thenApplyAsync((res) -> {
        //The return value shall prevail the last return            return 10 + res;
        }, service);

The following three ways Both tasks must be completed，This task is triggered
//Combining two futures, obtaining the return result of the two future tasks, and returning the return value of the current taskpublic <U,V> CompletableFuture<V> thenCombine(
        CompletionStage<? extends U> other,
        BiFunction<? super T,? super U,? extends V> fn)

public <U,V> CompletableFuture<V> thenCombineAsync(
        CompletionStage<? extends U> other,
        BiFunction<? super T,? super U,? extends V> fn)

public <U,V> CompletableFuture<V> thenCombineAsync(
        CompletionStage<? extends U> other,
        BiFunction<? super T,? super U,? extends V> fn, Executor executor) 

//Combining two futures, getting the return results of the two future tasks, and then processing the task, without a return value.public <U> CompletableFuture<Void> thenAcceptBoth(
        CompletionStage<? extends U> other,
        BiConsumer<? super T, ? super U> action)

public <U> CompletableFuture<Void> thenAcceptBothAsync(
        CompletionStage<? extends U> other,
        BiConsumer<? super T, ? super U> action)
        
public <U> CompletableFuture<Void> thenAcceptBothAsync(
        CompletionStage<? extends U> other,
        BiConsumer<? super T, ? super U> action, Executor executor) 
        
//Combining two futures does not need to obtain the result of futures, only two futures are processed after completing the taskpublic CompletableFuture<Void> runAfterBoth(CompletionStage<?> other,Runnable action) 

public CompletableFuture<Void> runAfterBothAsync(CompletionStage<?> other,Runnable action) 
                                                     
public CompletableFuture<Void> runAfterBothAsync(CompletionStage<?> other,Runnable action,Executor executor)

        CompletableFuture<Integer> future01 = (() -> {
            //Task A            (().getId());
            ("As soon as the mission ends");
            return 10/2;
        }, service);
        CompletableFuture<String> future02 = (() -> {
            //Task A            (().getId());
            ("Task 2 ends");
            return "future02";
        }, service);
        //The results cannot be sensed        CompletableFuture<Void> future03void = (future02, () -> {
            ("Task Three Execution End");
        }, service);
        //You can sense and obtain the results of the first two tasks        CompletableFuture<Void> future03No = (future02, (res1, res2) -> {
            ("Task Three Execution End");
        }, service);
        CompletableFuture<String> future03 = (future02, (res1, res2) -> {
            ("Task Three Execution End");
            return res1 + "-" + res2;
        }, service);

//One of the two tasks has been completed, get its return value, process the task and have a new return valuepublic <U> CompletableFuture<U> applyToEither( CompletionStage<? extends T> other, Function<? super T, U> fn) 

public <U> CompletableFuture<U> applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T, U> fn)
        
public <U> CompletableFuture<U> applyToEitherAsync(CompletionStage<? extends T>other,Function<? super T, U> fn,Executor executor) 
//One of the two tasks has been completed, get its return value, process the task, and there is no new return value.public CompletableFuture<Void> acceptEither(CompletionStage<? extends T> other, Consumer<? super T> action)

public CompletableFuture<Void> acceptEitherAsync(CompletionStage<? extends T> other,Consumer<? super T> action)

public CompletableFuture<Void> acceptEitherAsync(CompletionStage<? extends T> other,Consumer<? super T> action,Executor executor)
//One of the two tasks has been completed, and there is no need to get the result of future, the task is processed, and no value is returned.public CompletableFuture<Void> runAfterEither(CompletionStage<?> other,Runnable action)

public CompletableFuture<Void> runAfterEitherAsync(CompletionStage<?> other,Runnable action)
                                                       
public CompletableFuture<Void> runAfterEitherAsync(CompletionStage<?> other,Runnable action,Executor executor)

		 /**
          * If one of two tasks is completed, then three will be executed.
          *
          */
CompletableFuture<Object> future01 = (() -> {
            //Task A            try {
                (3000);
            } catch (InterruptedException e) {
                ();
            }
            (().getId());
            ("As soon as the mission ends");

            return 10/2;
        }, service);
        CompletableFuture<Object> future02 = (() -> {
            //Task A            (().getId());

            ("Task 2 ends");
            return "future02";
        }, service);
        //Don't perceive the result, and I don't return the value either        (future02,()->{
            ("Task Three Execution End");
        },service);
        //Sense the result, and it does not return the value        (future02,(res)->{
            //Sense the result that the thread has processed and completed            ("Task Three Execution End"+res);
        },service);
        //See the result and return your own return value        CompletableFuture<String> stringCompletableFuture = (future02, res -> {
            return "Task Three Results" + res;
        }, service);

//Waiting for all tasks to completepublic static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs)
//As long as there is a task completedpublic static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs)

CompletableFuture<Object> future01 = (() -> {
            //Task A            (().getId());
            ("As soon as the mission ends");

            return 10/2;
        }, service);
        CompletableFuture<Object> future02 = (() -> {
            //Task A            (().getId());
            try {
                (3000);
            } catch (InterruptedException e) {
                ();
            }
            ("Task 2 ends");
            return "future02";
        }, service);
        //This method is blocking waiting and is not recommended to use it here        //();
        //();
        
		//Waiting for all tasks to complete will not block        CompletableFuture<Void> allOf= (future01, future02);
        //Waiting for all to be completed (two tasks are executed at the same time)        ();
        ("end");
        (()+""+());
        //Only one completes        CompletableFuture<Object> anyOf= (future01, future02);
        ();
        (());