异步处理（CompletableFutrue）应用笔记

线程的实现方式

线程的实现方式

import org.springframework.stereotype.Component;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author guanglin.ma
 * @date 2023-12-29 15:51
 */
public class ThreadTest {


    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //thread使用
        ThreadDemo01 threadDemo01 = new ThreadDemo01();
        ThreadDemo01 threadDemo011 = new ThreadDemo01();

        threadDemo01.start();
        threadDemo011.start();

        //实现runnable
        ThreadDemo02 threadDemo02 = new ThreadDemo02();
        new Thread(threadDemo02).start();
        new Thread(() -> System.out.println("当前线程:" + Thread.currentThread().getName())).start();

        // 通过Callable接口来实现  FutureTask 本质上是一个Runnable接口
        FutureTask futureTask = new FutureTask<>(new MyCallable());
        new Thread(futureTask).start();

        // 阻塞等待子线程的执行完成，然后获取线程的返回结果
        System.out.println(futureTask.get());

    }

    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10,
                                                                   10, TimeUnit.SECONDS, new LinkedBlockingQueue(100),
                                                                   Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());


}


//继承Thread
class ThreadDemo01 extends Thread {
    @Override
    public void run() {
        System.out.println("当前线程:" + Thread.currentThread().getName());
    }
}

//实现Runnable接口
class ThreadDemo02 implements Runnable {
    @Override
    public void run() {
        System.out.println("当前线程:" + Thread.currentThread().getName());
    }
}

//Callable接口
class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("当前线程:" + Thread.currentThread().getName());
        return 10;
    }
}

获取线程的区别

通过上面的介绍我们发现获取线程的方式

• 继承Thread对象
• 实现Runnable接口
• 实现Callable接口
• 线程池

继承Thread对象和实现Runnable接口没有办法获取返回结果的，实现Callable接口可以获取线程的返回结果。当然这三种方式都不能控制我们的资源，线程池可以控制资源。

线程池的详解

线程池的创建方式

• 通过Executors的静态方法

• 通过 new ThreadPoolExecutor方式创建

  public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler){.......}
  

  ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10,
            10, TimeUnit.SECONDS, new LinkedBlockingQueue(100),
            Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
  

  参数	作用
  corePoolSize	核心线程数，线程池创建好后就准备就绪的线程数量，一直存在
  maximumPoolSize	最大线程数量，控制资源
  keepAliveTime	存活时间，如果当前线程数量如果大于核心线程数量，释放空闲的线程 最大线程-核心数量
  unit	时间单位
  BlockingQueue	阻塞队列，如果任务很多，就会把多的任务放在队列中，默认队列的长度是 Integer.MAX 那这个就太大了，所以我们需要指定队列的长度
  threadFactory	线程的工厂
  handler	如果队列满了，按照指定的拒绝策略执行任务；当线程数大于最大线程数的时候会执行的淘汰策略

线程池的执行顺序

- 1.先判断核心线程是否已满，未满分配线程
- 2.任务队列是·否已满，未满放入队列
- 3.是否达到最大的线程数量，未达到创建新的线程
- 4.通过对应的reject指定的拒绝策略进行处理

- 有一个线程池，core：5，max：50，queue：100，如果并发是200，那么线程池是怎么处理的？
- 首先 200个中的前面5个会直接被核心线程处理，然后6个到105个会加入到阻塞队列中，然后106到155的请求在最大线程数中，那么会创建对应的线程来处理这些请求，之后剩下的45个请求会被直接放弃

线程池好处

• 降低资源消耗
• 提高响应速度
• 提高线程的管理

CompletableFutrue

概念

Future是Java 5添加的类，用来描述一个异步计算的结果。你可以使用** isDone方法检查计算是否完成，或者使用 get阻塞住调用线程，直到计算完成返回结果，可以使用 cancel方法停止任务的执行。
虽然 Future以及相关使用方法提供了异步执行任务的能力，但是对于结果的获取却是很不方便，只能通过阻塞或者轮询的方式得到任务的结果。阻塞的方式显然和我们的异步编程的初衷相违背，轮询的方式又会耗费无谓的CPU资源。
CompletableFuture，提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合CompletableFuture的方法。

创建异步对象

CompletableFuture<Void> voidCompletableFuture = CompletableFuture.runAsync(() -> {
    System.out.println("线程开始了...");
    int i = 100 / 50;
    System.out.println("线程结束了...");
}, threadPoolExecutor);
System.out.println("runAsync获取的线程的返回结果是：" + voidCompletableFuture.get());

CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
    System.out.println("线程开始了...");
    int i = 100 / 50;
    System.out.println("线程结束了...");
    return i;
}, threadPoolExecutor);
System.out.println("supplyAsync获取的线程的返回结果是：" + integerCompletableFuture.get());

//线程开始了...
//线程结束了...
//runAsync获取的线程的返回结果是：null
//线程开始了...
//线程结束了...
//supplyAsync获取的线程的返回结果是：2

whenComplete和handle方法

当CompletableFuture的计算结果完成，或者抛出异常的时候，可以执行特定的Action。
whenComplete 可以获取异步任务的返回值和抛出的异常信息，但是不能修改返回结果

//异步完成后，接收异步结果进行处理，如果异步没有返回结果，则第一个参数为null,第二个参数为异常
public CompletableFuture<T> whenComplete(BiConsumer<? super T,? super Throwable> action);
public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T,? super Throwable> action);
public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T,? super Throwable> action, Executor executor);

CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("线程开始了...");
            int i = 100 / 50;
            System.out.println("线程结束了...");
            return i;
        }, threadPoolExecutor).whenComplete((res, e)->{
            System.out.println(res);
        });
        System.out.println("supplyAsync获取的线程的返回结果是：" + integerCompletableFuture.get());

exceptionally 当异步任务跑出了异常后会触发的方法，如果没有抛出异常该方法不会执行

CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
    System.out.println("线程开始了...");
    int i = 100 / 0;
    System.out.println("线程结束了...");
    return i;
}, threadPoolExecutor).exceptionally((e)->{
    System.out.println(e);
    return Integer.valueOf("123");
});
System.out.println("supplyAsync获取的线程的返回结果是：" + integerCompletableFuture.get());


//线程开始了...
//java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
//supplyAsync获取的线程的返回结果是：123

handle 可以获取异步任务的返回值和抛出的异常信息，而且可以显示的修改返回的结果

public <U> CompletableFuture<U> handle(BiFunction<? super T, Throwable, ? extends U> fn) ;
public <U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn) ;
public <U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn, Executor executor) ;

CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
    System.out.println("线程开始了...");
    int i = 100 / 2;
    System.out.println("线程结束了...");
    return i;
}, threadPoolExecutor).handle((res,e)->{
    System.out.println(res);
    System.out.println(e);
    return res;
});
System.out.println("supplyAsync获取的线程的返回结果是：" + integerCompletableFuture.get());

//线程开始了...
//线程结束了...
//50
//null
//supplyAsync获取的线程的返回结果是：50

线程串行方法

带有Async默认是异步执行的。这里所谓的异步指的是不在当前线程内执行
thenApply 方法：当一个线程依赖另一个线程时，获取上一个任务返回的结果，并返回当前任务的返回值。

public <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);

CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
    System.out.println("线程开始了...");
    int i = 100 / 2;
    System.out.println("线程结束了...");
    return i;
}, threadPoolExecutor).thenApply((res)->{
    System.out.println(res);
    return res+1;
}).thenApply((res)->{
    System.out.println(res);
    return res;
});
System.out.println("supplyAsync获取的线程的返回结果是：" + integerCompletableFuture.get());

//线程开始了...
//线程结束了...
//50
//51
//supplyAsync获取的线程的返回结果是：51

thenAccept方法：消费处理结果。接收任务的处理结果，并消费处理，无返回结果。

public CompletionStage<Void> thenAccept(Consumer<? super T> action);
public CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action);
public CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action,Executor executor);

CompletableFuture<Void> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("线程开始了...");
            int i = 100 / 2;
            System.out.println("线程结束了...");
            return i;
        }, threadPoolExecutor).thenAccept((res)->{
            System.out.println(res+1);
        });
        System.out.println("supplyAsync获取的线程的返回结果是：" + integerCompletableFuture.get());

//线程开始了...
//线程结束了...
//51
//supplyAsync获取的线程的返回结果是：null

thenRun方法：只要上面的任务执行完成，就开始执行thenRun，只是处理完任务后，执行 thenRun的后续操作

public CompletionStage<Void> thenRun(Runnable action);
public CompletionStage<Void> thenRunAsync(Runnable action);
public CompletionStage<Void> thenRunAsync(Runnable action,Executor executor);

CompletableFuture<Void> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
    System.out.println("线程开始了..."+Thread.currentThread().getName());
    int i = 100 / 5;
    System.out.println("线程结束了..."+Thread.currentThread().getName());
    return i;
}, threadPoolExecutor).thenRun(()->{
    System.out.println("thenRun..."+Thread.currentThread().getName());
});
System.out.println("supplyAsync获取的线程的返回结果是：" + integerCompletableFuture.get());

//线程开始了...pool-1-thread-1
//线程结束了...pool-1-thread-1
//thenRun...pool-1-thread-1
//supplyAsync获取的线程的返回结果是：null

两个都完成

thenCombine ：可以获取前面两线程的返回结果，本身也有返回结果

public <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);

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务1 线程开始了..." + Thread.currentThread().getName());
    int i = 100 / 5;
    System.out.println("任务1 线程结束了..." + Thread.currentThread().getName());
    return i;
}, threadPoolExecutor);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务2 线程开始了..." + Thread.currentThread().getName());
    int i = 100 /10;
    System.out.println("任务2 线程结束了..." + Thread.currentThread().getName());
    return i;
}, threadPoolExecutor);

CompletableFuture<String> thenCombine = future1.thenCombine(future2, (res1, res2) -> {
    System.out.println("任务3执行了");
    return res1 + "_" + res2;
});
System.out.println(thenCombine.get());

//任务1 线程开始了...pool-1-thread-1
//任务1 线程结束了...pool-1-thread-1
//任务2 线程开始了...pool-1-thread-2
//任务2 线程结束了...pool-1-thread-2
//任务3执行了
//20_10

thenAcceptBoth:可以获取前面两线程的返回结果，本身没有返回结果

public 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);

future1.thenAcceptBoth(future2,(res1, res2) -> {
    System.out.println("任务3执行了"+res1 + "_" + res2);
});

//任务3执行了20_10

runAfterBoth：不可以获取前面两线程的返回结果，本身也没有返回结果

与其他雷同

future1.runAfterBoth(future2,() -> {
    System.out.println("任务3执行了runAfterBoth");
});

两个任务完成一个

runAfterEither:不能获取完成的线程的返回结果，自身也没有返回结果

与其他雷同

future1.runAfterEitherAsync(future2,()->{
    System.out.println("任务3执行了....");
},executor);

acceptEither:可以获取线程的返回结果，自身没有返回结果

与其他雷同

future1.acceptEitherAsync(future2,(res)->{
    System.out.println("res = " + res);
},executor);

applyToEither:既可以获取线程的返回结果，自身也有返回结果

与其他雷同

CompletableFuture<String> stringCompletableFuture = future1.applyToEitherAsync(future2, (res) -> {
    System.out.println("res = " + res);
    return res + "-->OK";
}, executor);

多任务组合

allOf：等待所有任务完成

public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs);

CompletableFuture<Void> allOf = CompletableFuture.allOf(future1, future2, future3);
    allOf.get();// 阻塞在这个位置，等待所有的任务执行完成
    System.out.println("主任务执行完成..." + future1.get() + " :" + future2.get() + " :" + future3.get());
}

//主任务执行完成...20 :10 :10

anyOf：只要有一个任务完成

public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs);

CompletableFuture<Object> anyOf = CompletableFuture.anyOf(future1, future2, future3);
anyOf.get();
System.out.println("主任务执行完成..." + anyOf.get());//其中的一个


//