线程池 & 异步编排

最新推荐文章于 2022-11-14 15:18:52 发布
最新推荐文章于 2022-11-14 15:18:52 发布
阅读量406 收藏 1
点赞数 1
分类专栏： 分布式 文章标签： 线程池 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45620373/article/details/111350993
版权

目录


1、异步


01、初始化线程的4种方式


异步1


创建线程的4种方式

  • 1、继承Thread

  • 2、实现Runnable接口

  • 3、实现Callable接口+FutureTask(可以拿到返回结果，可以处理异常)

  • 4、线程池

    给线程池直接提交任务：

    • service.execute(new Runnable01());

    提交任务的两种方式：

    • 1）、submit 可以获取任务的返回值
    • 2）、executors不获取任务的返回值（只是执行）

总结

我们以后再业务代码里面，以上三种启动线程的方式都不用。将所有的多线程异步任务都交给线程池执行


区别

继承Thread、实现Runnable不能得到返回值。实现Callable可以获取返回值
继承Thread、实现Runnable、实现Callable都不能控制资源，可能导致服务器资源耗尽
线程池可以控制资源，性能稳定。


  • 测试代码
//  测试线程池
public class ThreadTest {

//4、线程池
    //创建一个固定数量的线程池 此处为创建10个
    /* 系统中池只有一两个，每个异步任务，提交给线程池让它去执行 */ //此处为只有一个池
    public static ExecutorService service = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main ... start ...");

//1、继承Thread
//        Thread01 thread1 = new Thread01();
//        thread1.start(); //启动线程
        /***
         * main ... start ...
         * main ... end ...
         * 当前线程：11
         * 运行结果：5
         */

//2、实现Runnable
//        Runable01 runable01 = new Runable01();
//        new Thread(runable01).start();
        /***
         * main ... start ...
         * main ... end ...
         * 当前线程：11
         * 运行结果：5
         */

//3、实现Callable接口+FutureTask
//        FutureTask<Integer> task = new FutureTask<>(new Callable01());
//        new Thread(task).start();
        /***
         * main ... start ...
         * main ... end ...
         * 当前线程：11
         * 运行结果：5
         */
//3.1）、等待整个线程执行完成，获取返回结果 -> 阻塞等待
//        Integer integer = task.get();
//        System.out.println("返回结果：" + integer);
        /***
         * 可以看到两个执行顺序不一样，使用get()方法需等待task线程执行结束，才可以执行main线程
         * main ... start ...
         * 当前线程：11
         * 运行结果：5
         * 返回结果：5
         * main ... end ...
         */

//4、创建好线程池之后，使用线程池【线程池方式】
//4.1）、给线程池提交任务
//        service.submit(); //可以获取任务的返回值
        service.execute(new Runable01()); //不获取任务的返回值（只是执行）
        /***
         * main ... start ...
         * main ... end ...
         * 当前线程：11
         * 运行结果：5
         */

        System.out.println("main ... end ...");
    }

    //1、继承Thread
    public static class Thread01 extends Thread{
        @Override
        public void run() {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("运行结果：" + i);
        }
    }

    //2、实现Runnable
    public static class Runable01 implements Runnable{
        @Override
        public void run() {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("运行结果：" + i);
        }
    }

    //3、实现Callable接口+FutureTask
    //需要指定泛型。泛型就是方法的返回值类型。
    public static class Callable01 implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("运行结果：" + i);
            return i;
        }
    }

}

02、线程池


创建线程池方式2：【须传入线程池的7大参数】

ThreadPoolExecutor executor = new ThreadPoolExecutor();


线程池的7大参数

参数说明作用及解释
corePoolSize核心线程数线程池，创建好以后就准备就绪的线程数量，就等待接收异步任务去执行 【只要线程池不销毁，就会一直存在，除非设置了 allowCoreThreadTimeOut (允许核心线程池超时)】 示例：5个 Thread thread = new Thread(); thread.start();
maximumPoolSize最大线程数量控制资源
keepAliveTime存活时间如果当前正在运行的线程数量大于core数量 释放空闲的线程(maximumPoolSize-corePoolSize)。只要线程空闲大于指定的keepAliveTime;
unit时间单位
BlockingQueue workQueue阻塞队列如果任务有很多。就会将多的任务放在队列里面 只要有线程空闲，就会去队列里面取出新的任务继续执行 示例：new LinkedBlockingQueue<>(),默认是Integer的最大值。可能导致内存不够，需要传入压力测试后的定制数量
ThreadFactory线程创建的工厂
RejectedExecutionHandler handler处理队列满了的情况如果队列满了，按照我们指定的拒绝策略，拒绝执行

执行流程

ThreadPoolExecutor executor = new ThreadPoolExecutor(
			5,
            200,
            10,
            TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(100000),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy()
);

说明：

  1. 线程池创建，准备好core数量的核心线程，准备接受任务
  2. core满了，就将再进来的任务放入阻塞队列中。空闲的core就会自己去阻塞队列获取任务执行
  3. 阻塞队列满了，就直接开新线程执行，最大只能开到max指定的数量
  4. max都执行完成，(max-core)数量空闲的线程会在keepAliveTime指定的时间后，自动销毁，释放空闲的线程。最终保持到core的大小
  5. 如果线程开到了max数量，还有新任务进来，就会使用RejectedExecutionHandler拒绝任务

示例：

一个线程池 core 7, max 20, queue 50, 100并发进来怎么分配的？

  • 7个会立即执行。
  • 50个进入队列。
  • 队列满了可以再开启线程，再开13【max-core】个进行执行。
  • 剩下30个就是用拒绝策略，拒绝策略一般都是丢弃，如果不想丢弃还要执行，可以使用CallerRunsPolicy策略

常见的4种线程池

线程池说明
newCachedThreadPool创建一个可缓存的线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 core是0，所有都可以回收
newFixedThreadPool创建一个固定大小线程池，可控制线程最大并发数，超出的线程会在队列中等待。core=max，都不可回收
newScheduledThreadPool定时任务的线程池
newSingleThreadExecutor创建一个单线程化的线程池，后台从队列里面获取任务，挨个执行

异步2


2、CompletableFuture异步编排


在这里插入图片描述


01、创建异步对象


CompletableFuture提供了4个静态方法来创建异步对象

public static CompletableFuture<Void> runAsync(Runnable runnable)
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)
  • runAsync()无返回值。
  • supplyAsync()有返回值。

没有指定Executor的方法会使用ForkJoinPool.commonPool() 作为它的线程池执行异步代码。如果指定线程池，则使用指定的线程池运行。以下所有的方法都类同。

可以传入自定义的线程池。不指定线程池的话会使用默认的线程池

  • 示例
public class ThreadTest {

    //创建一个固定数量的线程池 此处为创建10个
    public static ExecutorService execute = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main ... start ...");
//1、runAsync()方法
//        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
//            System.out.println("当前线程：" + Thread.currentThread().getId());
//            int i = 10 / 2;
//            System.out.println("运行结果：" + i);
//        }, execute);
        /***
         * main ... start ...
         * main ... end ...
         * 当前线程：11
         * 运行结果：5
         */

//2、supplyAsync方法
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果：" + i);
            return i;
        }, execute);
        System.out.println("返回值 = " + future.get());
        /***
         * main ... start ...
         * 当前线程：11
         * 运行结果：5
         * 返回值 = 5
         * main ... end ...
         */

        System.out.println("main ... end ...");
    }
}

02、计算结果完成时的回调方法


当CompletableFuture的计算结果完成，或者抛出异常的时候，可以执行特定的Action。主要是下面的方法：

//可以处理异常，无返回值，当前一个线程成功执行之后，还可以做别的事情，但是这个线程还是和前一个线程一样
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)
//可以处理异常，有返回值
public CompletableFuture<T> exceptionally(Function<Throwable,? extends T> fn)

方法不以Async结尾，意味着Action使用相同的线程执行，而Async可能会使用其他线程执行（如果是使用相同的线程池,也可能会被同一个线程选中执行)

  • 示例
public class ThreadTest {

    //创建一个固定数量的线程池 此处为创建10个
    public static ExecutorService execute = Executors.newFixedThreadPool(10);
  	
  	/***
  	*	方法执行完成后的感知
  	*/
 	public static void main(String[] args) throws ExecutionException, InterruptedException {
		System.out.println("main ... start ...");  
      	CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 0;
            System.out.println("运行结果：" + i);
            return i;
            //传入的两个参数： result：结果  exception：异常
        }, execute).whenComplete((result,exception) -> {
            //虽然可以感知异常信息。但是无法返回数据（类似于监听器）
            System.out.println("异步任务为执行成功......结果是："+ result + "，异常是："+ exception);
        }).exceptionally(throwable -> {
            //可以感知异常信息。同时可以返回默认值
            return 10;
        });
        System.out.println("返回值 = " + future.get()); //此处因为异常返回的是定义的异常返回默认值

        System.out.println("main ... end ...");
    }
}
  • 输出
main ... start ...
当前线程：11
异步任务为执行成功......结果是：null，异常是：java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
返回值 = 10
main ... end ...

03、handle 方法 -> 最终处理


handle()：可以对执行返回的结果进行进一步处理并返回自定义值

  • 示例
public class ThreadTest {
	
    //创建一个固定数量的线程池 此处为创建10个
    public static ExecutorService execute = Executors.newFixedThreadPool(10);
  	
  	/***
  	*	方法执行完成后的处理
  	*/
 	public static void main(String[] args) throws ExecutionException, InterruptedException {
      	System.out.println("main ... start ...");
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 0;
            System.out.println("运行结果：" + i);
            return i;
            //传入的两个参数： result：结果  thr：异常
        }, execute).handle((result,thr) -> {
            if (result != null){
                return result * 2;
            }
            if (thr != null){
                return 0;
            }
            return 1;
        });
        System.out.println("返回值 = " + future.get());

        System.out.println("main ... end ...");
    }
}
  • 输出
main ... start ...
当前线程：11
返回值 = 0
main ... end ...

04、线程串行化


//不能接收上一步的执行结果，无返回值
public CompletableFuture<Void>  thenRun(Runnable action)
public CompletableFuture<Void>  thenRunAsync(Runnable action)
public CompletableFuture<Void>  thenRunAsync(Runnable action, Executor executor)
    
//能接收上一步结果，并消费处理该结果，无返回值
public 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)   
    
//能接收上一步结果，并消费处理该结果，有返回值
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)
  • T：上一个任务返回结果的类型
  • U：当前任务的返回值类型
  • 带有Async默认是异步执行的。这里所谓的异步指的是不在当前线程内执行。
  • 测试thenRun 不能接收上一步的执行结果，无返回值
public class ThreadTest {
	
    //创建一个固定数量的线程池 此处为创建10个
    public static ExecutorService execute = Executors.newFixedThreadPool(10);
	public static void main(String[] args) throws ExecutionException, InterruptedException {
      	System.out.println("main ... start ...");
		//串行化
    	CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
    		System.out.println("当前线程：" + Thread.currentThread().getId());
        	int i = 10 / 4;
        	System.out.println("运行结果：" + i);
        	return i;
 		}, execute).thenRunAsync(() -> {
        	System.out.println("任务2启动了......");
    	}, execute);
    	System.out.println("返回值 = " + future.get());
    	System.out.println("main ... end ...");
    }
}
  • 输出
main ... start ...
当前线程：11
运行结果：2
任务2启动了......
返回值 = null  //无返回值
main ... end ...
  • 测试thenAccept 能接收上一步结果，并消费处理该结果，无返回值
public class ThreadTest {
	
    //创建一个固定数量的线程池 此处为创建10个
    public static ExecutorService execute = Executors.newFixedThreadPool(10);
	public static void main(String[] args) throws ExecutionException, InterruptedException {
      	System.out.println("main ... start ...");
		//串行化
        CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 4;
            System.out.println("运行结果：" + i);
            return i;
        }, execute).thenAcceptAsync((result) -> {
            System.out.println("任务2启动了......");
            System.out.println("result = " + result);
        }, execute);
    	System.out.println("返回值 = " + future.get());
    	System.out.println("main ... end ...");
    }
}
  • 输出
main ... start ...
当前线程：11
运行结果：2
任务2启动了......
result = 2  //接收上一步的结果
返回值 = null  //无返回值
main ... end ...
  • 测试thenApply 能接收上一步结果，并消费处理该结果，有返回值
public class ThreadTest {
	
    //创建一个固定数量的线程池 此处为创建10个
    public static ExecutorService execute = Executors.newFixedThreadPool(10);
	public static void main(String[] args) throws ExecutionException, InterruptedException {
      	System.out.println("main ... start ...");
		//串行化
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 4;
            System.out.println("运行结果：" + i);
            return i;
        }, execute).thenApplyAsync((result) -> {
            System.out.println("任务2启动了......");
          	System.out.println("result = " + result);
            return "Hello" + result;
        }, execute);
    	System.out.println("返回值 = " + future.get());
    	System.out.println("main ... end ...");
    }
}
  • 输出
main ... start ...
当前线程：11
运行结果：2
任务2启动了......
result = 2  //接收上一步的结果
返回值 = Hello2  //有返回值
main ... end ...

05、两任务组合 - 都要完成


以下方法的触发条件：--->之前的两个任务都完成，才开始执行合并任务。A&&B==1-->执行C的关系

//runAfterBoth：不获取future结果，没有返回值
public CompletionStage<Void> runAfterBoth(CompletionStage<?> other,Runnable action);
public CompletionStage<Void> runAfterBothAsync(CompletionStage<?> other,Runnable action);
public CompletionStage<Void> runAfterBothAsync(CompletionStage<?> other,Runnable action,Executor executor);

//thenAcceptBoth：获取两个future任务的结果，没有返回值
public <U> CompletionStage<Void> thenAcceptBoth(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action);
public <U> CompletionStage<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action);
public <U> CompletionStage<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action,Executor executor);

//thenCombine：获取两个future任务的结果，有返回值
public <U,V> CompletionStage<V> thenCombine(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn);
public <U,V> CompletionStage<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn);
public <U,V> CompletionStage<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn,Executor executor);
  • 示例
public class ThreadTest {
	
    //创建一个固定数量的线程池 此处为创建10个
    public static ExecutorService execute = Executors.newFixedThreadPool(10);
	public static void main(String[] args) throws ExecutionException, InterruptedException {
      	System.out.println("main ... start ...");
//任务1
        CompletableFuture<Integer> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1线程启动...... 当前线程：" + Thread.currentThread().getId());
            int i = 10 / 4;
            System.out.println("任务1线程结束...... 运行结果：" + i);
            return i;
        }, execute);
//任务2
        CompletableFuture<String> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2线程启动...... 当前线程：" + Thread.currentThread().getId());
            System.out.println("任务2线程结束......");
            return "Hello";
        }, execute);
      	
//合并任务插入的位置..................
      	
        System.out.println("返回值 = " + future.get());
        System.out.println("main ... end ...");
    }
}
  • runAfterBoth：不获取future结果，没有返回值
        //合并任务1
        CompletableFuture<Void> future = future01.runAfterBothAsync(future02, () -> {
            System.out.println("任务3开始......");
        }, execute);
  • 输出
main ... start ...
任务1线程启动...... 当前线程：11
任务1线程结束...... 运行结果：2
任务2线程启动...... 当前线程：12
任务2线程结束......
任务3开始......
返回值 = null //没有返回值
main ... end ...
  • thenAcceptBoth：获取两个future任务的结果，没有返回值
        //合并任务2               f1 和 f2 分别是 future01 和 future02 的返回值
        CompletableFuture<Void> future = future01.thenAcceptBothAsync(future02, (f1, f2) -> {
            System.out.println("任务3开始...... 接收的结果分别是：" + f1 +" --> " + f2);
        }, execute);
  • 输出
main ... start ...
任务1线程启动...... 当前线程：11
任务1线程结束...... 运行结果：2
任务2线程启动...... 当前线程：12
任务2线程结束......
任务3开始...... 接收的结果分别是：2 --> Hello //接收前两个任务的结果
返回值 = null //没有返回值
main ... end ...
  • thenCombine：获取两个future任务的结果，有返回值
        //合并任务3               f1 和 f2 分别是 future01 和 future02 的返回值
        CompletableFuture<String> future = future01.thenCombineAsync(future02, (f1, f2) -> {
            System.out.println("任务3开始...... 接收的结果分别是：" + f1 + " --> " + f2);
            return f1 + " : " + f2;
        }, execute);
  • 输出
main ... start ...
任务1线程启动...... 当前线程：11
任务1线程结束...... 运行结果：2
任务2线程启动...... 当前线程：12
任务2线程结束......
任务3开始...... 接收的结果分别是：2 --> Hello //接收前两个任务的结果
返回值 = 2 : Hello //有返回值
main ... end ...

06、两个任务组合 - 一个完成


以下方法的触发条件：--->之前的两个任务任意完成一个，就开始执行合并任务。A||B==1-->执行C的关系

//runAfterEither：不获取future结果，没有返回值
public CompletionStage<Void> runAfterEither(CompletionStage<?> other,Runnable action);
public CompletionStage<Void> runAfterEitherAsync(CompletionStage<?> other,Runnable action);
public CompletionStage<Void> runAfterEitherAsync(CompletionStage<?> other,Runnable action,Executor executor);

//acceptEither：获取完成了的那个future的结果，没有返回值
public CompletionStage<Void> acceptEither(CompletionStage<? extends T> other,Consumer<? super T> action);
public CompletionStage<Void> acceptEitherAsync(CompletionStage<? extends T> other,Consumer<? super T> action);
public CompletionStage<Void> acceptEitherAsync(CompletionStage<? extends T> other,Consumer<? super T> action,Executor executor);

//applyToEither：获取完成了的那个future的结果，并且有返回值
public <U> CompletionStage<U> applyToEither(CompletionStage<? extends T> other,Function<? super T, U> fn);
public <U> CompletionStage<U> applyToEitherAsync(CompletionStage<? extends T> other,Function<? super T, U> fn);
public <U> CompletionStage<U> applyToEitherAsync(CompletionStage<? extends T> other,Function<? super T, U> fn,Executor executor);
  • 示例
  • 为了让示例效果明显，让任务2睡眠3s才执行任务2结束的语句
  • 注意方法1和方法2的返回值类型应该统一，此处都用Object
  • 接收返回值只接收一个，为执行完毕的那个方法的返回值
public class ThreadTest {
	
    //创建一个固定数量的线程池 此处为创建10个
    public static ExecutorService execute = Executors.newFixedThreadPool(10);
	public static void main(String[] args) throws ExecutionException, InterruptedException {
//任务1
        CompletableFuture<Object> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1线程启动...... 当前线程：" + Thread.currentThread().getId());
            int i = 10 / 4;
            System.out.println("任务1线程结束...... 运行结果：" + i);
            return i;
        }, execute);
//任务2
        CompletableFuture<Object> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2线程启动...... 当前线程：" + Thread.currentThread().getId());
            try {
                Thread.sleep(3000);
                System.out.println("任务2线程结束......");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Hello";
        }, execute);
      	
//合并任务插入的位置..................
      	
        System.out.println("返回值 = " + future.get());
        System.out.println("main ... end ...");
    }
}
  • runAfterEither：不获取future结果，没有返回值
        //合并任务1
        CompletableFuture<Void> future = future01.runAfterEitherAsync(future02, () -> {
            System.out.println("任务3开始......");
        }, execute);
  • 输出
任务1线程启动...... 当前线程：11
任务1线程结束...... 运行结果：2
任务2线程启动...... 当前线程：12
任务3开始...... //任务3提前执行
返回值 = null // 没有返回值
main ... end ...
任务2线程结束......
  • acceptEither：获取完成了的那个future的结果，没有返回值
        //合并任务2
        CompletableFuture<Void> future = future01.acceptEitherAsync(future02, (result) -> {
            System.out.println("任务3开始...... 执行完成的方法的结果是：" + result);
        }, execute);
  • 输出
main ... start ...
任务1线程启动...... 当前线程：11
任务1线程结束...... 运行结果：2
任务2线程启动...... 当前线程：12
任务3开始...... 执行完成的方法的结果是：2 //方法1先运行完毕，其返回值为2，且任务3提前执行
返回值 = null //没有返回值
main ... end ...
任务2线程结束......
  • applyToEither：获取完成了的那个future的结果，并且有返回值
        //合并任务3
        CompletableFuture<String> future = future01.applyToEitherAsync(future02, (result) -> {
            System.out.println("任务3开始...... 执行完成的方法的结果是：" + result);
            return result.toString() + "--> 乌拉";
        }, execute);
  • 输出
main ... start ...
任务1线程启动...... 当前线程：11
任务1线程结束...... 运行结果：2
任务2线程启动...... 当前线程：12
任务3开始...... 执行完成的方法的结果是：2 //任务1先运行完毕，其返回值为2，且任务3提前执行
返回值 = 2--> 乌拉 //有返回值
main ... end ...
任务2线程结束......

07、多任务组合


//allOf：等待所有任务完成
public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs)
    
//anyOf：只需要其中一个任务完成
public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs)
  • 示例
  • 需要任务1、任务2、任务3 依次执行
  • 为了让示例效果明显，让任务2睡眠3s才执行打印语句
  • 记得一定要执行get()或join()方法
  • allOf：等待所有任务完成
public class ThreadTest {
	
    //创建一个固定数量的线程池 此处为创建10个
    public static ExecutorService execute = Executors.newFixedThreadPool(10);
	public static void main(String[] args) throws ExecutionException, InterruptedException {
//任务1
        CompletableFuture<String> futureImg = CompletableFuture.supplyAsync(() -> {
            System.out.println("查询商品的图片信息");
            return "hello.jpg";
        },execute);
//任务2
        CompletableFuture<String> futureAttr = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
                System.out.println("查询商品的属性信息");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "黑色 256GB";
        },execute);
//任务3
        CompletableFuture<String> futureDesc = CompletableFuture.supplyAsync(() -> {
            System.out.println("查询商品的介绍");
            return "华为 P40";
        },execute);
	
//多任务组合allOf()
      	CompletableFuture<Void> future = CompletableFuture.allOf(futureImg, futureAttr, futureDesc);
        
        future.get(); //等待结果完成
//        future.join(); //使用join也可以
		
        System.out.println("之前任务的返回值 = " + futureImg.get() + " -> " + futureAttr.get() + " -> " + futureDesc.get());

        System.out.println("返回值 = " + future.get());
      
        System.out.println("main ... end ...");
    }
}
  • 输出结果
main ... start ...
查询商品的图片信息
查询商品的属性信息   //顺序执行
查询商品的介绍
之前任务的返回值 = hello.jpg -> 黑色 256GB -> 华为 P40 //可以获取之前任务的返回值
返回值 = null //方法返回值为空
main ... end ...

注意：不加get()或者join()的话，会发现执行顺序不对

在这里插入图片描述

  • anyOf：只需要其中一个任务完成
  • 不要去使用之前任务的返回值，因为get()是阻塞方法，会阻塞使得前3个任务都执行完成
public class ThreadTest {
	
    //创建一个固定数量的线程池 此处为创建10个
    public static ExecutorService execute = Executors.newFixedThreadPool(10);
	public static void main(String[] args) throws ExecutionException, InterruptedException {
//任务1
        CompletableFuture<String> futureImg = CompletableFuture.supplyAsync(() -> {
            System.out.println("查询商品的图片信息");
            return "hello.jpg";
        },execute);
//任务2
        CompletableFuture<String> futureAttr = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
                System.out.println("查询商品的属性信息");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "黑色 256GB";
        },execute);
//任务3
        CompletableFuture<String> futureDesc = CompletableFuture.supplyAsync(() -> {
            System.out.println("查询商品的介绍");
            return "华为 P40";
        },execute);
      
//多任务组合anyof()
        CompletableFuture<Object> future = CompletableFuture.anyOf(futureImg, futureAttr, futureDesc);
//        future.get(); //等待结果完成
//        future.join();

//        System.out.println("之前任务的返回值 = " + futureImg.get() + " -> " + futureAttr.get() + " -> " + futureDesc.get());  //这一行不要用了

        System.out.println("返回值 = " + future.get());
        System.out.println("main ... end ...");
    }
}
  • 输出
main ... start ...
查询商品的图片信息   //第一个任务执行后，后面的任务就不需要执行了
返回值 = hello.jpg //返回最先执行任务的返回值
main ... end ...
查询商品的介绍
查询商品的属性信息
乌拉1nl
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程池--异步编排
weixin_40961551的博客
04-16 543
线程池--异步编排线程池--异步编排为什么要使用线程池线程池的创建异步为什么要使用异步编程CompletableFuture具体使用方式线程池配置代码具体使用结语 线程池–异步编排 为什么要使用线程池 线程是稀缺资源，使用线程池可以减少创建和销毁线程的次数，每个工作线程都可以重复使用，可以最大限度减少线程的重复创建与销毁，有效预防OOM异常。 可以根据系统的承受能力，调整线程池中工作线程的数量，防止因为消耗过多内存导致服务器崩溃。 线程池的创建 public ThreadPoolExecutor(int
线程异步编排-线程池
Fong灵
08-24 1661
线程异步编排-线程池
线程相关笔记
chen_liuliu的博客
10-17 87
一、线程 1.继承Thread public static class Thread01 extends Thread { @Override public void run() { System.out.println("当前线程：" + Thread.currentThread().getId()); int i = 10 / 2; System.out.println("运行结果...
生产实践—线程池与异步任务编排
weixin_46522694的博客
05-06 246
现今的我们使用的服务器，大都是**多处理器多核**配置，资源充足。为**充分利用服务器性能**，**解耦调用线程与异步线程**，**提升响应速度**，使用**并发编程**成为了我们较好的选择。本文将就`JDK`提供的**线程池**，以文件上传的示例讲解线程池的打开方式。 ## **一、线程池介绍** JDK中提供的线程池核心实现类是`ThreadPoolExecutor`，使用***IDEA show Diagrams***查看类继承关系如下： ![1649818738(1).png](https://p
异步与线程池及异步编排
suchahaerkang的博客
09-14 1309
文章目录一、异步1、初始化线程池的4中方式2、开启线程测试二、线程池1、开发中为什么使用线程池？2、线程池七大参数：3、工作顺序：4、面试：三、CompletableFuture异步编排1、创建异步对象2、计算完成时回调方法3、线程串行化方法4、两任务组合 - 都要完成5、多任务组合四、测试代码五、异步编排小案例1、顺序获取详情、2、异步编排获取详情1、线程池配置2、代码优化 一、异步 在业务开发中，有很多异步场景，为了节约时间或或者提高系统的吞吐量，要做一些异步任务，在Java中要实现异步通常都是Thre
java并发编程 线程池 异步编排
08-04
java并发编程相关总结
线程—–同步异步，阻塞非阻塞
01-07
同步：阻塞式调用，调用方必须等待响应方执行完毕才会返回 例如：A接口调用B接口，B接口有内部的逻辑实现，再将B接口执行接口返回给A...1.耗时任务：主线程中提交耗时任务到线程池，然后通过Feture来异步获取任务执行
CompletableFuture 异步处理
07-16
总结，CompletableFuture是Java中处理异步编程的强大工具，它通过提供丰富的API和灵活的任务编排方式，简化了异步编程的复杂性，提升了代码的可读性和可维护性。开发者可以根据具体需求选择合适的方法，创建和组合...
美团动态线程池实践思路开源项目（DynamicTp），线程池源码解析及通知告警篇.doc
07-09
Executor 接口提供了一个 submit() 方法，可以提交任务并返回 Future 对象，以便可以异步地获取任务的执行结果。ExecutorService 接口继承自 Executor 接口，提供了生命周期管理的方法、返回 Future 的方法、批量...
程序员面试刷题的书哪个好-gulimall:古力商城
07-07
程序员面试刷题的书哪个好 ...高并发场景的编码方式、线程池、异步编排等的使用 压力测试与性能优化 各种集群技术的应用及区别 CI/CD的使用 ... 3、项目前置要求 SpringCloud SpringBoot Git、Maven Li
07 线程异步
weixin_30436101的博客
08-30 57
一个从网络获取json的例子： package com.qf.day07_asynctask_json; import java.io.InputStream; import java.net.HttpURLConnection; import java.net.MalformedURLException; import java.net.URL; import java.util.L...
线程-线程池-异步编排
qq_43128724的博客
12-22 393
一、线程回顾 public static final ExecutorService service = Executors.newFixedThreadPool(10); /** * 1.继承Thread * Thread01 thread = new Thread01(); * thread.start(); * * 2.实现Runnable接口 * Runnable01 runnable = new Runnable01(); * new Thread(
线程池详解
u014496893的博客
02-20 199
一、初始化线程池的4种方式 1、继承 Thread 2、实现 Runnable 3、实现 Callable 接口 + FutureTask（可以拿到返回结果，可以处理异常） 4、线程池 方式一和方式二，主进程无法获取线程的运行结果，不适用当前的场景 方式三：主进程可以获取当前先后曾的运行结果，但是不利于控制服务器中的线程资源。 方式四：通过如下两种方式初始化线程 Executors.newFixedThreadPool(3); //或者 new ThreadPollExecutor(corePoolSize
java自定义线程池的使用与异步编排
liulala16的专栏
09-23 531
java线程池，异步编排
分布式三大利器之《异步》 + 自定义线程池规则
spphacker的博客
05-09 316
一、异步线程最开始使用 这里橙线有使用到组合模式 所以可以看到开启线程的三种方法 1.继承Thread，实现其run方法 2.由于组合模式，给Thread构造器传入Runnable 即：new Thread(new Runnable{。。。}); 3.new Thread(new FutureTask(new Callable(){。。。 })) public static void main(String[] args) throws ExecutionException, InterruptedExc
CompletableFuture开启异步线程
weixin_44433826的博客
11-14 1292
CompletableFuture异步线程
Executor线程池、CompletableFuture 使用详解
打不死的小强lee的博客
08-01 9887
多线程框架Executor详解 CompletableFuture 使用详解
记一次生产问题--CompletableFuture默认线程池
热门推荐
u011381576的博客
04-20 2万+
在jdk7中，我们使用线程池可能会使用ExecutorService，默认有四种方式 Executors.newSingleeThreadPool() Executors.newFixedThreadPool() Executors.newCacheThreadPool() Executors.newScheduledThreadPool() 在jdk8中，CompletableF...
玩转CompletableFuture线程异步编排，看这一篇就够了
__Forward
11-15 1万+
1、CompletableFuture介绍 CompletableFuture可用于线程异步编排，使原本串行执行的代码，变为并行执行，提高代码执行速度。 学习异步编排先需要学习线程池和lambda表达式相关知识，学习线程池可以移步我的另一篇博客 ThreadPoolExecutor线程池理解 2、CompletableFuture使用 说明：使用CompletableFuture异步编排大多方法都会有一个重载方法，会多出一个executor参数，用来传来自定义的线程池，如果不传就会使用默认的线程池。 下文举
线程池和异步任务编排
最新发布
08-16
线程池和异步任务编排在业务开发中都是非常常见的技术。线程池的主要作用是管理和复用线程资源，避免频繁创建和销毁线程带来的开销。通过线程池，可以有效地控制并发线程的数量，提高系统的性能和响应速度。 总结...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值