JUC之线程池学习

已于 2022-03-02 15:35:58 修改
阅读量340 收藏
点赞数
分类专栏： springboot java 文章标签： 学习 java 开发语言
于 2022-02-20 22:43:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_45865428/article/details/123036197
版权

1、计算完成时回调

1.1、runAsync()无返回值

//创建线程池并设置大小
public static ExecutorService executor = Executors.newFixedThreadPool(10);

public static void main(String[] args) throws ExecutionException, InterruptedException {
    System.out.println("main执行");
    CompletableFuture<Void> runAsync = CompletableFuture.runAsync((() -> {
        System.out.println("线程池执行了");
    }), executor);
    System.out.println("main结束");
}

1.2、supplyAsync()有返回值

//方法完成后的感知
//创建线程池并设置大小
public static ExecutorService executor = Executors.newFixedThreadPool(10);

public static void main(String[] args) throws ExecutionException, InterruptedException {
    System.out.println("main执行");
    CompletableFuture<Integer> supplyAsync = CompletableFuture.supplyAsync((() -> {
        return 1;
    }), executor).whenCompleteAsync((res,excption)->{
        //异步任务完成时需要做的事情，可以获取异常信息但是无法修改返回数据
        //(res,excption)  res异步任务执行完的结果，excption异步任务执行的异常
    }).exceptionally(throwable -> {
        //出现异常时处理逻辑，可以返回默认值
        return 1;
    });
    System.out.println(supplyAsync.get());
    System.out.println("main结束");
}

2、handle()方法

//方法执行完成后的处理
//创建线程池并设置大小
public static ExecutorService executor = Executors.newFixedThreadPool(10);

public static void main(String[] args) throws ExecutionException, InterruptedException {
    System.out.println("main执行");
    CompletableFuture<Integer> supplyAsync = CompletableFuture.supplyAsync((() -> {
        return 1;
    }), executor).handle((res,excption)->{
        if (res != null){
            //方法正常执行完成
        }
        if (excption != null){
            //方法执行时出现异常的处理
        }
        return 1;
    });
    System.out.println(supplyAsync.get());
    System.out.println("main结束");
}

3、线程串行化

3.1、thenRunAsync(）无法获取上一步执行结果

//创建线程池并设置大小
public static ExecutorService executor = Executors.newFixedThreadPool(10);

public static void main(String[] args) throws ExecutionException, InterruptedException {
    System.out.println("main执行");
    CompletableFuture.supplyAsync((() -> {
        System.out.println("线程1开始了");
        return 1;
    }), executor).thenRunAsync(()->{
        System.out.println("线程2开始了");
    });
    System.out.println("main结束");
}

3.2、supplyAsync(）可以感知上一步执行结果，但无返回值

//创建线程池并设置大小
public static ExecutorService executor = Executors.newFixedThreadPool(10);
public static void main(String[] args) throws ExecutionException, InterruptedException {
    System.out.println("main执行");
    CompletableFuture.supplyAsync((() -> {
        System.out.println("线程1开始了");
        return 1;
    }), executor).thenAcceptAsync(res ->{
        System.out.println("上一步执行结果："+res);
    });
    System.out.println("main结束");
}

3.3、thenApplyAsync() 感知上一步结果，并返回处理完成的值

//创建线程池并设置大小
public static ExecutorService executor = Executors.newFixedThreadPool(10);
public static void main(String[] args) throws ExecutionException, InterruptedException {
    System.out.println("main执行");
    CompletableFuture<Integer> thenApplyAsync = CompletableFuture.supplyAsync((() -> {
        System.out.println("线程1开始了");
        return 1;
    }), executor).thenApplyAsync(res -> {
        System.out.println("上一步执行结果：" + res);
        return 2 + res;
    }, executor);
    System.out.println(thenApplyAsync.get());
    System.out.println("main结束");
}

4、两任务组合（都要完成）

4.1、runAfterBothAsync() 不能获取前面线程的执行结果且无返回值

//创建线程池并设置大小
public static ExecutorService executor = Executors.newFixedThreadPool(10);

public static void main(String[] args) throws ExecutionException, InterruptedException {
    System.out.println("main执行");
    CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync((() -> {
        System.out.println("线程1开始了");
        return 1;
    }), executor);
    CompletableFuture<String > future2 = CompletableFuture.supplyAsync((() -> {
        System.out.println("线程2开始了");
        return "hello";
    }), executor);
    future1.runAfterBothAsync(future2,()->{
        System.out.println("线程3执行，不能获取前面线程的执行结果且无返回结果");
    },executor);
    System.out.println("main结束");
}

4.2、thenAcceptBothAsync(）可以获取前面线程的值，但方法本身无返回值

//创建线程池并设置大小
public static ExecutorService executor = Executors.newFixedThreadPool(10);

public static void main(String[] args) throws ExecutionException, InterruptedException {
    System.out.println("main执行");
    CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync((() -> {
        System.out.println("线程1开始了");
        return 1;
    }), executor);
    CompletableFuture<String > future2 = CompletableFuture.supplyAsync((() -> {
        System.out.println("线程2开始了");
        return "hello";
    }), executor);
    future1.thenAcceptBothAsync(future2,(f1,f2)->{
        System.out.println("任务3 开始，前面线程的结果为："+f1+" "+f2);
    },executor);
    System.out.println("main结束");
}

4.3、thenCombineAsync() 可以获取前面线程的值，同时可以将结果返回

//创建线程池并设置大小
public static ExecutorService executor = Executors.newFixedThreadPool(10);

public static void main(String[] args) throws ExecutionException, InterruptedException {
    System.out.println("main执行");
    CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync((() -> {
        System.out.println("线程1开始了");
        return 1;
    }), executor);
    CompletableFuture<String > future2 = CompletableFuture.supplyAsync((() -> {
        System.out.println("线程2开始了");
        return "hello";
    }), executor);
    CompletableFuture<String> combineAsync = future1.thenCombineAsync(future2, (f1, f2) -> {
        return f1 + "" + f2;
    }, executor);
    System.out.println(combineAsync.get());
    System.out.println("main结束");
}

5、两任务组合（一个完成）

5.1、runAfterEitherAsync() 不能获取前面线程的值，也没有返回值

//创建线程池并设置大小
public static ExecutorService executor = Executors.newFixedThreadPool(10);

public static void main(String[] args) throws ExecutionException, InterruptedException {
    System.out.println("main执行");
    CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync((() -> {
        System.out.println("线程1开始了");
        return 1;
    }), executor);
    CompletableFuture<String > future2 = CompletableFuture.supplyAsync((() -> {
        System.out.println("线程2开始了");
        return "hello";
    }), executor);
    future1.runAfterEitherAsync(future2,()->{
        System.out.println("线程3开始");
    },executor);
    System.out.println("main结束");
}

5.2、acceptEitherAsync() 可以获取上一个线程的结果，但无返回值

//创建线程池并设置大小
public static ExecutorService executor = Executors.newFixedThreadPool(10);

public static void main(String[] args) throws ExecutionException, InterruptedException {
    System.out.println("main执行");
    CompletableFuture<Object> future1 = CompletableFuture.supplyAsync((() -> {
        System.out.println("线程1开始了");
        return 1;
    }), executor);
    CompletableFuture<Object > future2 = CompletableFuture.supplyAsync((() -> {
        System.out.println("线程2开始了");
        return "hello";
    }), executor);
    future1.acceptEitherAsync(future2,(res)->{
        System.out.println("线程3开始，上一个线程执行的结果："+res);
    },executor);
    System.out.println("main结束");
}

5.3、applyToEitherAsync() 可以获取上一个线程的结果，同时可以返回结果

//创建线程池并设置大小
public static ExecutorService executor = Executors.newFixedThreadPool(10);

public static void main(String[] args) throws ExecutionException, InterruptedException {
    System.out.println("main执行");
    CompletableFuture<Object> future1 = CompletableFuture.supplyAsync((() -> {
        System.out.println("线程1开始了");
        return 1;
    }), executor);
    CompletableFuture<Object > future2 = CompletableFuture.supplyAsync((() -> {
        System.out.println("线程2开始了");
        return "hello";
    }), executor);
    CompletableFuture<String> eitherAsync = future1.applyToEitherAsync(future2, (res) -> {
        System.out.println("线程3开始");
        System.out.println("上一个线程的结果" + res);
        return "线程3" + res;
    }, executor);
    System.out.println(eitherAsync.get());
    System.out.println("main结束");
}

6、多任务组合

6.1、allOf() 等待所有结果完成，再执行

//创建线程池并设置大小
public static ExecutorService executor = Executors.newFixedThreadPool(10);

public static void main(String[] args) throws ExecutionException, InterruptedException {
    System.out.println("main执行");
    CompletableFuture<Object> futureImg = CompletableFuture.supplyAsync((() -> {
        System.out.println("查询商品图片");
        return "hello.jpg";
    }), executor);
    CompletableFuture<Object> futureAttr = CompletableFuture.supplyAsync((() -> {
        System.out.println("查询商品属性");
        return "黑色 + 25G";
    }), executor);
    CompletableFuture<Object> futureDesc = CompletableFuture.supplyAsync((() -> {
        System.out.println("查询商品介绍");
        return "华为";
    }), executor);

    CompletableFuture<Void> allOf = CompletableFuture.allOf(futureImg, futureAttr, futureDesc);
    allOf.get();//等待所有结果完成
    System.out.println("main结束，结果是："+futureImg.get()+futureAttr.get()+futureDesc.get());
}

6.2、anyOf(）只要有一个线程执行完成，就执行下面的语句

//创建线程池并设置大小
public static ExecutorService executor = Executors.newFixedThreadPool(10);

public static void main(String[] args) throws ExecutionException, InterruptedException {
    System.out.println("main执行");
    CompletableFuture<Object> futureImg = CompletableFuture.supplyAsync((() -> {
        System.out.println("查询商品图片");
        return "hello.jpg";
    }), executor);
    CompletableFuture<Object> futureAttr = CompletableFuture.supplyAsync((() -> {
        System.out.println("查询商品属性");
        return "黑色 + 25G";
    }), executor);
    CompletableFuture<Object> futureDesc = CompletableFuture.supplyAsync((() -> {
        System.out.println("查询商品介绍");
        return "华为";
    }), executor);

    CompletableFuture<Object> anyOf = CompletableFuture.anyOf(futureImg, futureAttr, futureDesc);
    anyOf.get(); //只要有一个线程完成了，就执行
    System.out.println("main结束，结果是："+anyOf.get());
}

7、异步调用（多线程）下数据共享

//创建线程池并设置大小
public static ExecutorService executor = Executors.newFixedThreadPool(10);

public static void main(String[] args) throws ExecutionException, InterruptedException {
    System.out.println("main执行，线程ID:"+ Thread.currentThread().getId());
    //获取主线程的请求数据
    RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
    
    CompletableFuture<Object> futureImg = CompletableFuture.supplyAsync((() -> {
    	//每一个线程都来共享主线程的请求数据
   		RequestContextHolder.setRequestAttributes(requestAttributes);
    	System.out.println("异步线程，线程ID:"+ Thread.currentThread().getId());
        System.out.println("查询商品图片");
        return "hello.jpg";
    }), executor);
    CompletableFuture<Object> futureAttr = CompletableFuture.supplyAsync((() -> {
        //每一个线程都来共享主线程的请求数据
   		RequestContextHolder.setRequestAttributes(requestAttributes);
        System.out.println("异步线程，线程ID:"+ Thread.currentThread().getId());
        System.out.println("查询商品属性");
        return "黑色 + 25G";
    }), executor);
    CompletableFuture<Object> futureDesc = CompletableFuture.supplyAsync((() -> {
        //每一个线程都来共享主线程的请求数据
   		RequestContextHolder.setRequestAttributes(requestAttributes);
    	System.out.println("异步线程，线程ID:"+ Thread.currentThread().getId());
        System.out.println("查询商品介绍");
        return "华为";
    }), executor);

    CompletableFuture<Object> anyOf = CompletableFuture.anyOf(futureImg, futureAttr, futureDesc);
    anyOf.get(); //只要有一个线程完成了，就执行
    System.out.println("main结束，结果是："+anyOf.get());
}
【Java多线程】JUC之线程池(二)再次邂逅线程池ThreadPoolExecutor的原理
墩墩分墩
08-23 393
**一个线程池包括以下四个基本组成部分：** 1. 线程工厂（ThreadFactory）：用于创建并管理线程池，包括 创建线程池，销毁线程池，添加新任务； 2. 工作线程（Worker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务； 3. 任务接口（Runnable）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等； 4. 任务队列（workQueue）：用于存放待执行的任务。提供一种缓冲机制。
JUC学习 - 线程池2
TyuIn的博客
11-26 321
接上一篇博客https://blog.youkuaiyun.com/qq_43605444/article/details/121568416?spm=1001.2014.3001.5501 8、4种常见饱和策略 当线程池中队列已满，并且线程池已达到最大线程数，线程池会将任务传递给饱和策略进行处理。这些策略都实现了RejectedExecutionHandler接口。接口中有个方法： void rejectedExecution(Runnable r, ThreadPoolExecutor executor) 参数
【Java 8 新特性】Java CompletableFuture supplyAsync()
猫巳的博客
05-18 3万+
Java CompletableFuture supplyAsync与 thenApply() 一起使用自定义执行器 Executor与 whenComplete() 一起使用与流(Stream)一起使用参考文献 在此页面上，我们将提供Java CompletableFuture.supplyAsync()示例。 supplyAsync()是Java 8中引入的CompletableFuture静态方法。 方法supplyAsync()完成在ForkJoinPool.commonPool()或给定的Exec
Java8特性 - CompletableFuture的基础使用
Zong_0915的博客
10-19 1459
Java8特性 - CompletableFuture的基础使用
CompletableFuture详解
最新发布
print_helloword的博客
03-19 419
是Java 8引入的一个类，用于异步编程，它提供了强大的功能来帮助开发者实现非阻塞式的编程，支持函数式风格，并能有效避免回调地狱（Callback Hell）。异步非阻塞：任务可在独立线程中异步执行，不影响主线程。链式调用：支持函数式编程，方便链式处理。组合与聚合：能简单地将多个异步任务结果组合。异常处理：可对异步任务中的异常灵活处理。是现代Java编程不可缺少的利器，熟练使用它能极大提升代码的并发性能、响应效率和优雅性。尤其在高并发、微服务、异步调用等场景中，熟悉并掌握至关重要。
Java8 CompletableFuture runAsync等使用学习总结 submit() execute()等
weixin_44131922的博客
08-25 4389
返回的CompletableFuture是多个任务都执行完成后才会执行，只要有一个任务执行异常，则返回的 CompletableFuture 执行get方法时会抛出异常，如果都正常执行，则get返回null。指定某个任务执行异常时执行的回调方法，会将抛出异常作为参数传递到回调方法中，如果该任务正常执行则 exceptionally方法返回的CompletionStage的result就是该任务正常执行的结果。当某个任务执行完成后执行的回调方法，会将执行结果或者执行期间抛出的异常传递给回调方法。
异步多线程 CompletableFuture
qq_44845473的博客
07-17 693
jdk1.8异步多线程的使用示例
Springboot利用CompletableFuture异步执行线程（有回调和无回调）
weixin_42966151的博客
10-12 7260
项目中总会有需要异步执行来避免浪费时间资源的情况，这就需要异步操作。异步又分两种： 1、无回调：有一些执行过程对用户而言不需要反馈回调，只需要自己执行即可，且执行过程时间较长（某些第三方接口，如发送短信验证码、查取ip属地等等），如果同步执行，势必会影响到用户体验，这时候就可以使用CompletableFuture.runAsync()方法了。 2、有回调：在执行异步操作结束后，需要获得异步方法返回的值，然后再回调给用户展示，这时候就需要用到CompletableFuture.supplyAsync()
JUC和线程池的详细讲解
2401_83412087的博客
03-30 914
/创建原子类AtomicInterger, 设置初始值为1i < 1;i++) {//五个核心线程处理任务@Overridei1 < 1;i1++) {//先+1, 再获取//先获取, 再+1//先-1, 再获取//先获取, 再获取//先+指定的值, 再获取//先获取, 再+指定的值//获取值});CAS（ Compare And Swap）算法，比较和交换算法。CAS不需要和synchronized一样让对象具有独立性、互斥性保持线程安全。
JUC学习 - 线程池1
TyuIn的博客
11-26 388
一、线程池 1、什么是线程池 大家用jdbc操作过数据库应该知道，操作数据库需要和数据库建立连接，拿到连接之后才能操作数据库，用完之后销毁。数据库连接的创建和销毁其实是比较耗时的，真正和业务相关的操作耗时是比较短的。每个数据库操作之前都需要创建连接，为了提升系统性能，后来出现了数据库连接池，系统启动的时候，先创建很多连接放在池子里面，使用的时候，直接从连接池中获取一个，使用完毕之后返回到池子里面，继续给其他需要者使用，这其中就省去创建连接的时间，从而提升了系统整体的性能。 线程池和数据库连接池的原理也差不多
JUC多线程学习个人笔记
07-08
1. **线程池**：JUC通过Executor框架实现了线程池，允许开发者根据需求创建和管理线程。线程池可以减少线程创建和销毁的开销，提高系统的响应速度和资源利用率。线程池的核心组件包括ExecutorService、...
java8 supplyasync_【新特性】java8新特性
weixin_39992312的博客
02-27 1346
java8新特性异步编程CompletableFuture 实现异步编程supplyAsync 有返回值CompletableFuture f1 = CompletableFuture.supplyAsync(() -> "hello");runAsync参数是Runable没有返回值CompletableFuture runAsync = CompletableFuture.runAsy...
CompletableFuture详解~runAsync
小强快跑~~
02-27 3万+
这个例子创建一个一个异步执行的阶段： static void runAsyncExample() { CompletableFuture cf = CompletableFuture.runAsync(() -> { assertTrue(Thread.currentThread().isDaemon()); randomSleep(); }); assertFalse(cf.isDone()); sleepEnough();
CompletableFuture 看这篇操作就够了
AKA石头
10-24 1257
当来到 Java 8 函数式编程时代，CompletableFuture 使我们的代码变得很优雅且易懂，今天我来介绍下 CompletableFuture 在我们项目中的实际使用场景。
CompletableFuture 详解
qq_35215728的博客
11-01 733
CompletableFuture 是 Java 8 引入的一个类，位于 java.util.concurrent 包中，用于编写异步代码，提供了一个可编程的、可组合的异步编程框架。以下是 CompletableFuture 的使用环境和具体作用
JUC-CompletableFuture异步回调
思变的博客
12-28 305
1.无返回值的 runAsync 异步回调 2.有返回值的 supplyAsync 异步回调 public class CompletableFuture_ { public static void main(String[] args) throws Exception { //没有返回值的异步回调 runAsync() CompletableFuture<Void> completableFuture1 = CompletableFuture.ru
CompletableFuture 详解（二）：supplyAsync / runAsync 实现原理 源码分析
热门推荐
tongtest的博客
07-25 4万+
前面CompletableFuture详解（一）：基本概念及用法讲了CompletableFuture的使用，从这篇开始，我们深入了解CompletableFuture的实现，以便于大家更深入的理解CompletableFuture是如何运行的，这也有利于大家正确地使用CompletableFuture。 本篇主要介绍 supplyAsync和runAsync的实现。 1、supplyAsync的实现 我们主要看入参为Supplier的版本。因为另外一个版本的supplyAsync函数，除了增加了自定
Java 多线程工作之CompletableFuture.runAsync案例
u011556070的博客
01-26 3万+
在实际的工作中，我们会需要执行一些无返回的多线程任务以改善系统的运行效率。 接受kafka消息并对这些消息进行处理是一个典型案例，如果这里使用多线程的处理方式可以大大提高系统的处理性能。 以下就对CompletableFuture.runAsync的使用方式做一个案例展示 先定义一个处理的任务，这里可能是一个Runnable也可能是一个Callable，区别就是在于有无返回值 import lombok.extern.slf4j.Slf4j; /** * @author yhgu * @date 20
尚硅谷周阳JUC课程学习笔记分享
在JUC中，每个ReentrantLock实例都拥有一个与之关联的Condition实例，它提供了await、signal、signalAll等方法来实现条件变量的基本操作。 知识点10：JUC的其他辅助工具（Phaser, Exchanger） Phaser是一个可伸缩的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值