线程池与异步编排

最新推荐文章于 2023-08-02 14:44:59 发布
最新推荐文章于 2023-08-02 14:44:59 发布
阅读量141 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42732665/article/details/129109550
版权

1、线程回顾

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

  • 1、继承 Thread
public class ThreadTest {
    public static void main(String[] args) {
        System.out.println("main......start......");
   
        Thread01 thread01 = new Thread01();
        thread01.start();
        System.out.println("main......end......");
    }


    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 class ThreadTest {
    public static void main(String[] args) {
        System.out.println("main......start......");

        Thread02 thread02 = new Thread02();
        new Thread(thread02).start();
        System.out.println("main......end......");
    }

    public static class Thread02 implements Runnable{

        @Override
        public void run() {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果：" + i);
        }
    }
}
  • 3、实现 Callable 接口 + FutureTask （可以拿到返回结果，可以处理异常）
public class ThreadTest {
    public static void main(String[] args) {
        System.out.println("main......start......");

        FutureTask<Integer> futureTask = new FutureTask(new Callable01());
        new Thread(futureTask).start();
        // 阻塞等待整个线程执行完成，获取返回结果
        Integer res = futureTask.get();
        System.out.println("futureTask返回结果：" + res);
        System.out.println("main......end......");
    }

    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;
        }
    }
}
  • 4、线程池 ExecutorService
public class ThreadTest {
    public static void main(String[] args) {
        System.out.println("main......start......");

        // 当前系统中池只有一两个，每个异步任务，提交给线程池让它自己去执行就行
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        executorService.execute(new Thread02());
        System.out.println("main......end......");
    }

    public static class Thread02 implements Runnable{

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

区别：

  • 1、2不能得到返回值，3可以得到返回值
  • 1、2、3都不能控制资源
  • 4可以控制资源，性能稳定

在实际业务中，我们的业务代码里面，前面三个启动线程的方式都不用，而是使用线程池，性能稳定。应该将所有的多线程异步任务都交给线程池执行

1.2、线程池详解

1.2.1 线程池的七大参数

   public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)
  • int corePoolSize：核心线程数（一直存在）。线程池创建好以后就准备就绪的线程数量，就等待来接受异步任务取执行
  • int maximumPoolSize：最大线程数。线程池中允许的最大线程数。控制资源。
  • long keepAliveTime：存活时间。如果当前的线程数量大于核心线程数的时候，线程在最大多长时间没有接到新任务就会终止释放，最终保持线程池corePoolSize数量的线程数。
  • TimeUnit unit：时间单位
  • BlockingQueue< Runnable > workQueue：阻塞队列，用来存储等待执行的任务。如果当前对线程的需求超过了corePoolSize大小，就会放在这里等待空闲线程执行。
  • ThreadFactory threadFactory：创建线程的工厂，比如指定线程名。
  • RejectedExecutionHandler handler：拒绝策略，如果线程满了，线程池就会使用拒绝策略。

运行流程：

  • 1、线程池创建，准备好corePoolSize数量的核心线程，准备接收任务。
  • 2、新的任务进来，用corePoolSize准备好的空闲线程执行。
    • 1、 corePoolSize满了，就将再进来的任务放入阻塞队列workQueue中。等到corePoolSize中有空闲的线程了，就会自动去阻塞队列中获取任务执行。
    • 2、阻塞队列满了，就直接开新线程执行，最大只能开到maximumPoolSize指定的数量。
    • 3、maximumPoolSize都执行完毕了，超过corePoolSize数量的线程中，空闲的线程会在keepAliveTime指定的时间后自动销毁，最终保持在corePoolSize大小。
    • 4、如果线程数开到maximumPoolSize数量还不够，新任务进来就会使用RejectedExecutionHandler指定的拒绝策略进行处理。
  • 3、所有的线程创建都是由指定的ThreadFactory 创建的。

假设：
一个线程池 core 7； max 20 ，queue：50，100 并发进来怎么分配的；
先有7个任务进来直接执行，再接收50个任务进入阻塞队列中，然后再新开（20 - 7）13个任务执行，剩下（100 - 7 - 50 -13）30个默认拒绝策略。

1.2.2 常见的 4 种线程池

  • 1、newCachedThreadPool
    创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
  • newFixedThreadPool
    创建一个定长线程，可控制线程最大并发数，超出的线程会在队列中等待。
  • newScheduledThreadPool
    创建一个定长线程池，支持定时及周期性任务执行。
  • newSingleThreadExecutor
    创建一个单线程化的线城池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序（FIFO，LIFO，优先级）执行。

1.2.3 开发中为什么使用线程池

  • 降低资源的消耗
    • 通过重复利用已经创建好的线程降低线程的创建和销毁带来的损耗。
  • 提高响应速度
    • 因为线程池中的线程数没有超过线程池的最大上线时，有的线程处于等待分配任务的状态，当任务来时无需创建新的线程就能执行。
  • 提高线程的可管理性
    • 线程池会根据当前系统特点对池内的线程进行优化处理，减少创建和销毁线程带来的系统开销。无限的创建和销毁线程不仅消耗系统资源，还降低系统的稳定性，使用线程池进行统一分配。

2、CompletableFuture 异步编排

业务场景：
比如查询商品详情页的逻辑比较复杂，有些数据还需要远程调用，必然需要花费更多的时间。
在这里插入图片描述
假如商品详情页的每个查询，需要如下标注的时间才能完成
那么，用户需要 5.5s 后才能看到商品详情页的内容。很显然是不能接受的。如果有多个线程同时完成这 6 步操作，也许只需要 1.5s 即可完成响应。

Future 是 Java 5 添加的类，用来描述一个异步计算的结果。你可以使用isDone方法检查计
算是否完成，或者使用get阻塞住调用线程，直到计算完成返回结果，你也可以使用cancel 方法停止任务的执行。

虽然Future以及相关使用方法提供了异步执行任务的能力，但是对于结果的获取却是很不方便，只能通过阻塞或者轮询的方式得到任务的结果。阻塞的方式显然和我们的异步编程的初衷相违背，轮询的方式又会耗费无谓的 CPU 资源，而且也不能及时地得到计算结果，为什么不能用观察者设计模式当计算结果完成及时通知监听者呢？

很多语言，比如 Node.js，采用回调的方式实现异步编程。Java 的一些框架，比如Netty，自己扩展了 Java 的 Future接口，提供了addListener等多个扩展方法；Google guava 也提供了通用的扩展 Future；Scala 也提供了简单易用且功能强大的 Future/Promise 异步编程模式。

作为正统的 Java 类库，是不是应该做点什么，加强一下自身库的功能呢？

在 Java 8 中, 新增加了一个包含 50 个方法左右的类: CompletableFuture，提供了非常强大的Future 的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合 CompletableFuture 的方法。CompletableFuture 类实现了 Future 接口，所以你还是可以像以前一样通过get方法阻塞或者轮询的方式获得结果，但是这种方式不推荐使用。

CompletableFuture 和 FutureTask 同属于 Future 接口的实现类，都可以获取线程的执行结果。
在这里插入图片描述

2.1、创建异步对象

在这里插入图片描述
1、runXxxx 都是没有返回结果的，supplyXxx 都是可以获取返回结果的
2、可以传入自定义的线程池，否则就用默认的线程池；

public class CompletableFutureTest {
    // 自定义的线程池
    public static ExecutorService executorService = Executors.newFixedThreadPool(10);

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

        // 异步执行无返回值
        // CompletableFuture<Void> voidCompletableFuture = CompletableFuture.runAsync(() -> {
        //     System.out.println("当前线程：" + Thread.currentThread().getId());
        //     int i = 10 / 2;
        //     System.out.println("运行结果：" + i);
        // }, executorService);

        // 异步执行有返回值
        CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果：" + i);
            return i;
        }, executorService);
        Integer integer = integerCompletableFuture.get();
        System.out.println("获取的返回值：" + integer);

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

2.2、计算完成时回调方法

在这里插入图片描述

  • whenComplete 可以处理正常和异常的计算结果，exceptionally 处理异常情况。
  • whenComplete 和 whenCompleteAsync 的区别：
    • whenComplete：是执行当前任务的线程执行继续执行 whenComplete 的任务。
    • whenCompleteAsync：是执行把 whenCompleteAsync 这个任务继续提交给线程池来进行执行。

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

public class CompletableFutureTest {
    // 自定义的线程池
    public static ExecutorService executorService = Executors.newFixedThreadPool(10);

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

        // 异步执行无返回值
        // CompletableFuture<Void> voidCompletableFuture = CompletableFuture.runAsync(() -> {
        //     System.out.println("当前线程：" + Thread.currentThread().getId());
        //     int i = 10 / 2;
        //     System.out.println("运行结果：" + i);
        // }, executorService);

        // 异步执行有返回值
        // whenComplete：方法完成后的感知，不能修改返回数据
        // exceptionally：异常捕捉，同时能返回默认值
        CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
                    System.out.println("当前线程：" + Thread.currentThread().getId());
                    int i = 10 / 2;
                    System.out.println("运行结果：" + i);
                    return i;
                },executorService).whenComplete((res, exception) -> {
                    // 虽然能得到异常信息，但是没法修改返回数据。
                    System.out.println("异步任务成功完成了，结果是：" + res + ";异常时：" + exception);
                }).exceptionally(exception -> {
                    // 感知异常，同时返回默认值
                    return 10;
                });
        Integer integer = integerCompletableFuture.get();

        System.out.println("获取的返回值：" + integer);
        System.out.println("main......end......");
    }
}

2.3、handle 方法

在这里插入图片描述
和 complete 一样，可对结果做最后的处理（可处理异常），可改变返回值。

public class CompletableFutureTest {
    // 自定义的线程池
    public static ExecutorService executorService = Executors.newFixedThreadPool(10);

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

        /**
         * 方法完成后的处理，无论成功还是失败
         */
        CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果：" + i);
            return i;
        },executorService).handle((res, exception) -> {
            // 虽然能得到异常信息，但是没法修改返回数据。
            System.out.println("异步任务成功完成了，结果是：" + res + ";异常时：" + exception);
            if (res != null) {
                return res * 2;
            }
            if (exception != null) {
                return 12;
            }
            return 324;
        });
        Integer integer = integerCompletableFuture.get();

        System.out.println("获取的返回值：" + integer);
        System.out.println("main......end......");
    }
}

2.4、线程串行化方法

在这里插入图片描述

  • thenApply 方法：当一个线程依赖另一个线程时，获取上一个任务返回的结果，并返回当前任务的返回值。
  • thenAccept 方法：消费处理结果。接收任务的处理结果，并消费处理，无返回结果。
  • thenRun 方法：只要上面的任务执行完成，就开始执行 thenRun，只是处理完任务后，执行thenRun 的后续操作

带有 Async 默认是异步执行的。同之前。
以上都要前置任务成功完成。

Function<? super T,? extends U>

  • T：上一个任务返回结果的类型
  • U：当前任务的返回值类型
public class CompletableFutureTest {
    // 自定义的线程池
    public static ExecutorService executorService = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main......start......");
        /**
         * 线程串行化
         * 1、thenRun：不能获取到上一步的执行结果，无返回值
         *      .thenRunAsync(() -> {
         *             System.out.println("任务2启动了。。。。。");
         *         }, executorService);
         * 2、thenAcceptAsync：能接收上一步的执行结果，无返回值
         *      .thenAcceptAsync(res -> {
         *             System.out.println("任务2启动了，上一步的执行结果：" + res);
         *         }, executorService);
         * 3、thenApplyAsync：技能接收上一步的执行结果，又有返回值
         *      .thenApplyAsync((res) -> {
         *             System.out.println("任务2启动了，上一步的执行结果：" + res);
         *             return "hello" + res;
         *         }, executorService);
         */
        CompletableFuture<String> stringCompletableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果：" + i);
            return i;
        }).thenApplyAsync((res) -> {
            System.out.println("任务2启动了，上一步的执行结果：" + res);
            return "hello" + res;
        }, executorService);
        System.out.println(stringCompletableFuture.get());
        System.out.println("main......end......");
    }
}

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

在这里插入图片描述
在这里插入图片描述
两个任务必须都完成，触发该任务。

  • thenCombine：组合两个 future，获取两个 future 的返回结果，并返回当前任务的返回值
  • thenAcceptBoth：组合两个 future，获取两个 future 任务的返回结果，然后处理任务，没有返回值。
  • runAfterBoth：组合两个 future，不需要获取 future 的结果，只需两个future 处理完任务后，处理该任务。
public class CompletableFutureTest {
    // 自定义的线程池
    public static ExecutorService executorService = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main......start......");
        CompletableFuture<Integer> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1开始：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("任务1结束：" + i);
            return i;
        }, executorService);

        CompletableFuture<String> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2开始：" + Thread.currentThread().getId());
            System.out.println("任务2结束：");
            return "hello";
        }, executorService);

        // runAfterBothAsync：不能接收前两个任务的结果，无返回值
        // future01.runAfterBothAsync(future02, ()->{
        //     System.out.println("任务1和2执行完成后，任务3开始。。。");
        // }, executorService);

        // thenAcceptBothAsync：能接收前两个任务的返回结果，无返回值
        // future01.thenAcceptBothAsync(future02, (f1,f2)->{
        //     System.out.println("任务1和2执行完成后，任务3开始。。。");
        //     System.out.println("任务1执行结果：" + f1);
        //     System.out.println("任务2执行结果：" + f2);
        // }, executorService);

        // thenCombineAsync：既能接收前两个任务的返回结果，又有返回值
        CompletableFuture<String> stringCompletableFuture = future01.thenCombineAsync(future02, (f1, f2) -> {
            System.out.println("任务1和2执行完成后，任务3开始。。。");
            System.out.println("任务1执行结果：" + f1);
            System.out.println("任务2执行结果：" + f2);
            return f1 + "：" + f2;
        }, executorService);
        System.out.println("任务3完成后结果：" + stringCompletableFuture.get());

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

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

在这里插入图片描述
在这里插入图片描述
当两个任务中，任意一个 future 任务完成的时候，执行任务。

  • applyToEither：两个任务有一个执行完成，获取它的返回值，处理任务并有新的返回值。
  • acceptEither：两个任务有一个执行完成，获取它的返回值，处理任务，没有新的返回值。
  • runAfterEither：两个任务有一个执行完成，不需要获取 future 的结果，处理任务，也没有返回值。
public class CompletableFutureTest {
    // 自定义的线程池
    public static ExecutorService executorService = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main......start......");
        CompletableFuture<Object> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1开始：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("任务1结束：" + i);
            return i;
        }, executorService);

        CompletableFuture<Object> future02 = CompletableFuture.supplyAsync(() -> {

            System.out.println("任务2开始：" + Thread.currentThread().getId());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("任务2结束：");

            return "hello";
        }, executorService);

        /**
         * 两任务组合 - 一个完成
         */
        // runAfterEitherAsync：不能接收前两个任务的结果，无返回值
        // future01.runAfterEitherAsync(future02, ()->{
        //     System.out.println("任务1和2只要有一个执行完成后，任务3开始。。。");
        // }, executorService);

        //acceptEitherAsync：能接收前两个任务中任一个的结果，无返回值
        // future01.acceptEitherAsync(future02, res -> {
        //     System.out.println("任务1和2只要有一个执行完成后，任务3开始。。。,之前的结果为：" + res);
        // }, executorService);

		// applyToEitherAsync：既能接收前两个任务中任一个的结果，又有返回值
        CompletableFuture<String> stringCompletableFuture = future01.applyToEitherAsync(future02, res -> {
            System.out.println("任务1和2只要有一个执行完成后，任务3开始。。。,之前的结果为：" + res);
            return res + " world!";
        }, executorService);
        System.out.println("任务3完成后结果：" + stringCompletableFuture.get());
        
        System.out.println("main......end......");
    }
}

2.7、多任务组合

在这里插入图片描述

  • allOf：等待所有任务完成
  • anyOf：只要有一个任务完成
public class CompletableFutureTest {
    // 自定义的线程池
    public static ExecutorService executorService = Executors.newFixedThreadPool(10);

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

        /**
         * 多任务组合
         */
        CompletableFuture<String> futureImg = CompletableFuture.supplyAsync(() -> {
            System.out.println("查询商品图片信息");
            return "hello.jpg";
        }, executorService);
        CompletableFuture<String> futureAttr = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("查询商品属性信息");
            return "黑色+256G";
        }, executorService);
        CompletableFuture<String> futureDesc = CompletableFuture.supplyAsync(() -> {
            System.out.println("查询商品描述信息");
            return "华为手机";
        }, executorService);

        // allOf 所有任务完成才执行
        // CompletableFuture<Void> voidCompletableFuture = CompletableFuture.allOf(futureImg, futureAttr, futureDesc);
        // 阻塞等待所有任务完成 才会执行主线程
        // voidCompletableFuture.get();
        // System.out.println("多任务组合完成。。。。。。。。。。");
        // System.out.println("结果为：" + futureImg.get() + "====" + futureAttr.get() + "====" + futureDesc.get());

        // anyOf 只要有一个任务完成才执行
        CompletableFuture<Object> anyOf = CompletableFuture.anyOf(futureImg, futureAttr, futureDesc);
        // 阻塞等待  只要有一个任务完成 就会执行主线程
        System.out.println("结果为：" + anyOf.get());

        System.out.println("main......end......");
    }
}
秦垦打工人ლ(°◕‵ƹ′◕ლ)
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
线程池--异步编排
weixin_40961551的博客
04-16 543
线程池--异步编排线程池--异步编排为什么要使用线程池线程池的创建异步为什么要使用异步编程CompletableFuture具体使用方式线程池配置代码具体使用结语 线程池–异步编排 为什么要使用线程池 线程是稀缺资源，使用线程池可以减少创建和销毁线程的次数，每个工作线程都可以重复使用，可以最大限度减少线程的重复创建与销毁，有效预防OOM异常。 可以根据系统的承受能力，调整线程池中工作线程的数量，防止因为消耗过多内存导致服务器崩溃。 线程池的创建 public ThreadPoolExecutor(int
线程池异步编排
leiPlus的博客
06-01 148
package com.ray.test; import com.alibaba.fastjson.TypeReference; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public cl
异步编排（线程池）
weixin_55034383的博客
03-06 247
使用线程池进行异步请求
线程-线程池-异步编排
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(
线程异步编排-线程池
Fong灵
08-24 1661
线程异步编排-线程池
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 的方法、批量...
数据导入与实时进度条实现
07-28
例如，使用Apache Airflow或Luigi这样的工作流管理系统来编排任务，控制数据导入的顺序和并发性，以优化资源利用率。 在实际应用中，我们还需要考虑到错误处理和日志记录，确保在数据导入过程中出现的问题能够被...
线程相关笔记
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("运行结果...
异步编程利器：CompletableFuture详解 ｜Java 开发实战
阿星君
06-19 1028
06日阅读 1005 关注 前言 文正在参加「Java主题月 - Java 开发实战」， 我们异步执行一个任务时，一般是用线程池Executor去创建。如果不需要有返回值， 任务实现Runnable接口；如果需要有返回值，任务实现Callable接口，调用Executor的submit方法，再使用Future获取即可。如果多个线程存在依赖组合的话，我们怎么处理呢？可使用同步组件CountDownLatch、CyclicBarrier等，但是比较麻烦。其实有简单的方法，就是用Compele..
线程池&异步编排
dgdxfgfdfdb的博客
06-07 370
线程池和异步编排的使用方式
193、商城业务-异步-异步复习
pyd1040201698的博客
09-06 209
package com.atguigu.gulimall.search.thread; import java.util.concurrent.*; public class ThreadTest { public static ExecutorService service = Executors.newFixedThreadPool(10); public static void main(String[] args) throws Executio...
生产实践——线程池与异步任务编排
q66562636的博客
04-17 671
现今的我们使用的服务器，大都是多处理器多核配置，资源充足。为充分利用服务器性能，解耦调用线程与异步线程，提升响应速度，使用并发编程成为了我们较好的选择。本文将就JDK提供的线程池，以文件上传的示例讲解线程池的打开方式。 一、线程池介绍 JDK中提供的线程池核心实现类是ThreadPoolExecutor，使用IDEA show Diagrams查看类继承关系如下： 顶层接口Executor仅提供了一个void execute(Runnable command)方法 ，将任务定义与任务执行解耦，
异步与线程池及异步编排
suchahaerkang的博客
09-14 1309
文章目录一、异步1、初始化线程池的4中方式2、开启线程测试二、线程池1、开发中为什么使用线程池？2、线程池七大参数：3、工作顺序：4、面试：三、CompletableFuture异步编排1、创建异步对象2、计算完成时回调方法3、线程串行化方法4、两任务组合 - 都要完成5、多任务组合四、测试代码五、异步编排小案例1、顺序获取详情、2、异步编排获取详情1、线程池配置2、代码优化 一、异步 在业务开发中，有很多异步场景，为了节约时间或或者提高系统的吞吐量，要做一些异步任务，在Java中要实现异步通常都是Thre
异步与线程池-异步编排详解
cqdddgs的博客
08-02 432
异步 线程池 异步编排真实案例
Java异步编排结合线程池实现多任务按需执行案例
厉害哥哥的博客
05-17 965
前言 正文 结语
线程池和异步任务编排
最新发布
08-16
- *1* *2* *3* [异步与线程池及异步编排](https://blog.csdn.net/suchahaerkang/article/details/108580038)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值