线程串行化方法

最新推荐文章于 2023-07-27 15:48:32 发布
置顶 最新推荐文章于 2023-07-27 15:48:32 发布
阅读量566 收藏 1
点赞数 1
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDN877425287/article/details/107548933
版权

单任务

这个些是无法感知Completablefuturec的返回结果的，这里前一个线程任务必须是Completablefuturec

//这个些是无法感知Completablefuturec的返回结果的，这里前一个线程任务必须是Completablefuturec
//public Completionstage<void> thenRun (Runnable action);//没有加Async采用当前线程执行接下来的任务
//public Completionstage<void> thenRunAsync (Runnable action);//采用Async就使用新的线程执行接下来的任务
//public Completionstage<void> thenRunAsync (Runnable action, Executor executor);//采用Async就使用新的线程执行接下来的任务，并且指定线程来执行任务


  		CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程ID-->" + Thread.currentThread().getId());
            int i = 10 / 1;
            return i;
        },executorService).thenRunAsync(()->{
            System.out.println("任务2启动");
            System.out.println("当前线程ID-->" + Thread.currentThread().getId());
        },executorService);

这个可以感知Completablefuturec的返回结果的Consumer super就是上一个Completablefuture的执行结果action代表接下来处理的任务

//这个可以感知Completablefuturec的返回结果的Consumer super就是上一个Completablefuture的执行结果action代表接下来处理的任务
//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> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程ID-->" + Thread.currentThread().getId());
            int i = 10 / 1;
            return i;
        },executorService).thenAcceptAsync(res->{
            System.out.println("当前线程ID-->" + Thread.currentThread().getId());
            System.out.println("任务2启动");
            System.out.println(res);
        },executorService);

这个不但能感知上个线程任务结束的返回值，还能在自己当前任务结束后同样带有返回值出去，

//这个不但能感知上个线程任务结束的返回值，还能在自己当前任务结束后同样带有返回值出去，
// T就是接收上个任务的返回值，U就是自己任务结束后返回出去的值，fn就是自己要处理的任务
//public <U>  Completablefuture<U> thenApply (Functionc ? super T,? extends Us fn)
//public <U> CompletableFuturec<U> thenApplyAsync(Function ? super T, ? extends Us fn)
//public <U> Completablefuturec<U> thenApplyAsync(Functionc ? super T, ? extends U > fn, Executor executor)
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程ID-->" + Thread.currentThread().getId());
            int i = 10 / 1;
            return i;
        }, executorService);
        future.thenApplyAsync(res->{
            System.out.println("当前线程ID-->" + Thread.currentThread().getId());
            System.out.println("任务2启动");
            System.out.println(res);
            return 10;
        },executorService);
        System.out.println(future.get());

两任务组合-都要完成

当任务1和任务2执行完成后执行任务3，但是任务3只能感知任务1、任务2任务执行完毕，无法得到结果

 		CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前任务1，线程ID-->" + Thread.currentThread().getId());
            int i = 10 / 1;
            return i;
        }, executorService);

        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前任务2，线程ID-->" + Thread.currentThread().getId());
            int i = 10 / 2;
            return i;
        }, executorService);


        future1.runAfterBothAsync(future2, () -> {
            System.out.println("当前任务3，线程ID-->" + Thread.currentThread().getId());
        }, executorService);

当任务1、任务2执行完毕后，任务三能感知到任务1、任务2执行完毕，并且还能得到返回值–但是任务3无法返回值

  		CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前任务1，线程ID-->" + Thread.currentThread().getId());
            int i = 10 / 1;
            return i;
        }, executorService);

        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前任务2，线程ID-->" + Thread.currentThread().getId());
            int i = 10 / 2;
            return i;
        }, executorService);

        future1.thenAcceptBothAsync(future2,(f1,f2)->{
            System.out.println("当前任务3，线程ID-->" + Thread.currentThread().getId());
            System.out.println("任务1返回值："+f1);
            System.out.println("任务2返回值："+f2);
        },executorService);

当任务1、任务2执行完毕后，任务3能感知，并且能的带任务1、任务2的值，任务3还能自己返回值出去

     CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前任务1，线程ID-->" + Thread.currentThread().getId());
            int i = 10 / 1;
            return i;
        }, executorService);

        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前任务2，线程ID-->" + Thread.currentThread().getId());
            int i = 10 / 2;
            return i;
        }, executorService);

        CompletableFuture<Integer> future3 = future1.thenCombineAsync(future2, (f1, f2) -> {
            System.out.println("当前任务3，线程ID-->" + Thread.currentThread().getId());
            System.out.println("任务1返回值："+f1);
            System.out.println("任务2返回值："+f2);
            return f1 + f2;
        }, executorService);

        System.out.println(future3.get());

两任务组合-其中一个完成即可

只能感知到任务结束，无法感知两个任务的执行结果

  		CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前任务1，线程ID-->" + Thread.currentThread().getId());
            int i = 10 / 1;
            return i;
        }, executorService);

        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前任务2，线程ID-->" + Thread.currentThread().getId());
            int i = 10 / 2;
            return i;
        }, executorService);
        
		future1.runAfterEitherAsync(future2,()->{
		    System.out.println("当前任务3，线程ID-->" + Thread.currentThread().getId());
		},executorService);

感知两个任务中先执行完的任务的执行结果

		CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前任务1，线程ID-->" + Thread.currentThread().getId());
            int i = 10 / 1;
            return i;
        }, executorService);

        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前任务2，线程ID-->" + Thread.currentThread().getId());
            int i = 10 / 2;
            return i;
        }, executorService);
		future1.acceptEitherAsync(future2,(res)->{
            System.out.println("当前任务3，线程ID-->" + Thread.currentThread().getId());
            System.out.println("得到其中的一个返回值"+res);
        },executorService);

感知两个任务中先执行完的任务的执行结果，并且可以返回值出去

		CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前任务1，线程ID-->" + Thread.currentThread().getId());
            int i = 10 / 1;
            return i;
        }, executorService);

        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前任务2，线程ID-->" + Thread.currentThread().getId());
            int i = 10 / 2;
            return i;
        }, executorService);
        
         CompletableFuture<Integer> future3 = future1.applyToEitherAsync(future2, (res) -> {
            System.out.println("当前任务3，线程ID-->" + Thread.currentThread().getId());
            System.out.println("得到其中的一个返回值" + res);
            return res + 10;
        }, executorService);
        System.out.println(future3.get());

多任务组合

等待任务全部执行完毕，这里的任务都是并行执行的

		System.out.println("主线程开始");
        long t1=new Date().getTime();
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前任务1，线程ID-->" + Thread.currentThread().getId());
            int i = 10 / 1;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return i;

        }, executorService);

        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前任务2，线程ID-->" + Thread.currentThread().getId());
            int i = 10 / 2;
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return i;
        }, executorService);

        CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前任务3，线程ID-->" + Thread.currentThread().getId());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            int i = 10 / 5;
            return i;
        }, executorService);

        CompletableFuture<Void> conformityF = CompletableFuture.allOf(future1, future2, future3);
        conformityF.get();//等待所有任务执行完成

        System.out.println("任务1返回值-->"+future1.get());
        System.out.println("任务2返回值-->"+future2.get());
        System.out.println("任务3返回值-->"+future3.get());
        System.out.println(new Date().getTime()-t1);
        System.out.println("主线程结束");

等待任意一个任务执行完毕后结束

		System.out.println("主线程开始");
        long t1=new Date().getTime();
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前任务1，线程ID-->" + Thread.currentThread().getId());
            int i = 10 / 1;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return i;

        }, executorService);

        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前任务2，线程ID-->" + Thread.currentThread().getId());
            int i = 10 / 2;
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return i;
        }, executorService);

        CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前任务3，线程ID-->" + Thread.currentThread().getId());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            int i = 10 / 5;
            return i;
        }, executorService);

        CompletableFuture<Object> conformityF = CompletableFuture.anyOf(future1, future2, future3);
        conformityF.get();//等待所有任务执行完成
        System.out.println("第一个执行完成的返回值-->"+conformityF.get());//那么这里拿到的就是第一个任务的返回值
        System.out.println(new Date().getTime()-t1);
        System.out.println("主线程结束");

实际场景

 @Override
    public String doPost(ChannelHandlerContext ctx, FullHttpRequest request, JSONObject params) {
        Out.debug("---------------获取关注状态-拉黑状态----------------");
        String userId=params.getString("userId");
        String tagId=params.getString("tagId");
        CompletableFuture<Integer> t1 = CompletableFuture.supplyAsync(() -> {
            return UserFollowDB.getCountByUid(userId,tagId);//是否是关注0.是未关注 1.是关注
        });

        CompletableFuture<Integer> t2 = CompletableFuture.supplyAsync(() -> {
            return  UserBlacklistDB.getCountByUserId(userId, tagId) == true ? 1 : 0;//是否是黑0.没拉黑 1.拉黑
        });

        CompletableFuture<JSONObject> t3 = t1.thenCombineAsync(t2, (f1, f2) -> {
            JSONObject res = new JSONObject();
            res.put("isAttention", f1);
            res.put("isBlock", f2);
            return res;
        });
        JSONObject res=null;
        try {
            res=t3.get();
        } catch (InterruptedException e) {
            return error(ErrorCodeList.SERVER_ERROR);
        } catch (ExecutionException e) {
            e.printStackTrace();
            return error(ErrorCodeList.SERVER_ERROR);
        }
        return success(res);
    }

这个接口是获取用户A，用户B之间是否关注，是否拉黑的，由于关注、拉黑操作需要入两次数据库，一般写法就是先查关注、在往下执行查询是否拉黑，那么假设关注查询需要100毫秒、拉黑查询也需要100毫秒，那么这样没做任何处理的话就需要200毫秒，那么我们使用任务编排后，只需要100毫秒即可执行完成！！！

程序员劝退师-TAO
关注
专栏目录
线程异步编排串行（CompletableFuture）
伍妖捌的小屋
06-27 408
美图 创建异步对象 CompletableFuture提供了四个静态方法来创建一个异步操作 无返回值 不需要指定线程池，使用默认线程池 CompletableFuture<Void> runAsync(Runnable runnable); 需要指定线程池，使用指定线程池 CompletableFuture<Void> runAsync(Runnable runnable, Executor executor) 有返回 不需要指定线程池，使用默认线程池 Comple
多线程设计模式-串行线程封闭模式
Guilai1990的博客
06-08 518
定义：通过将多个并发的任务存入队列实现任务的串行化，并为这些串行化的任务创建唯一的一个工作者线程进行处理 由于只有唯一的工作者线程访问，对其的访问无须加锁，因此避开了锁的的开销和锁带来的问题 串行线程封闭模式 Serializer: 负责对外暴露服务接口以及工作者线程的生命周期管理，并将客户端对其的并发任务调用转换为相应的任务以实现服务串行化 service: 表示将串...
线程与串行化
u011281810的博客
06-27 937
sleep：使线程停止一段时间执行，时间到后，不一定立即恢复，依照优先级和时间片‘wait ：调用wait的线程暂停执行，等待其他线程调用该同步监视器的notify或notifyAll方法，被唤醒、windows32环境中，线程的3中基本模型：单线程——一个线程完成所有应用程序任务单元线程——多个线程，单元线程的代码在自己的线程中执行，并限制在自己的单元中，所有线程都在主应用程序内存中各自的字段范...
线程池串行化
weixin_45365220的博客
05-07 762
线程池串行化 SerializingExecutor KeyAffinityExecutor
实现线程串行执行
weixin_33859665的博客
08-16 408
2019独角兽企业重金招聘Python工程师标准>>> ...
T1、T2、T3三个线程怎么串行执行？
最新发布
qq_43479493的博客
07-27 465
这里只是一些简单基础的使用，自己浅薄的见解。
在实时检测系统中用Delphi开发多线程串行通信程序.pdf
06-20
在实时检测系统中，开发多线程串行通信程序是一个关键任务，特别是在涉及单片机与上位机交互的应用中。Delphi作为一种高效且功能强大的编程语言，由于其面向对象的可视化特性，常用于Windows环境下的图形界面和用户...
线程串行并行调度实现
she_cool_的博客
10-17 1186
线程串行并行调度实现 问题描述 问题描述：线程A、B、C并行执行，然后和线程D串行执行，如何实现。 问题具体化：现在有A、B、C三个线程，每一个线程分别完成打印0～4的任务，有一个线程D，在A、B、C完成打印之后打印“Hello world!”。 解决思路 我们都知道线程就是用来实现并发执行的，而要实现的结果是在A、B、C三个线程并行执行完之后才执行线程D的任务，那么就需要获取等到A、B、C三个线...
详解Node.js串行化流程控制
10-19
Node.js串行化流程控制是Node.js中处理多个异步任务按顺序执行的一种模式。在Node.js中，由于其单线程的特性，处理异步任务时很容易出现嵌套回调（也称为回调地狱），导致代码难以阅读和维护。串行化流程控制可以...
线程的并行与串行
m0_46261647的博客
05-23 636
1.串行Sequential：一个一个完成任务，先做任务A，完成后，再做任务B。。。。更耗时 2.并发Concurrent：先做任务A，当A在等待的时候，开启任务B，以此类推，也就是说这三个任务交替完成 3.并行Parallel：三个任务同时开始，总耗时取决于需要时间最长的那个任务。 4.并发可以提高事务的处理效率，即一段时间内可以处理或者完成更多的事情。 5.并行是一种更为严格、理想的并发 6.从硬件角度来说，如果单核cpu，一个处理器一次只能执行一个线程的情况下，处理器可以使用时间片轮转技术，可以让CP
Java线程的相关方法串联线程知识
effine
09-03 1381
~ start()  启动线程方法 ~ run()  调用start（）方法时，真正执行的就是该方法的方法体 ~ sleep()  让当前线程睡眠，睡眠到期自动苏醒，并进入可运行状态，而不是运行状态 ~ yield（） 暂停当前正在执行的线程对象，JVM线程调度程序基于优先级的抢先机制调用其他优先级高的线程，优先级的取值范围1 (Thread.MIN_PRIORITY) -- 10( Thr
java 串行线程_Java并发之串行线程池实例解析
weixin_33421437的博客
02-12 431
前言做Android的这两年时间，通过研究Android源码，也会Java并发处理多线程有了自己的一些理解。那么问题来了，如何实现一个串行的线程池呢？思路何为串行线程池呢？也就是说，我们的Runnable对象应该有个排队的机制，它们顺序从队列尾部进入，并且从队列头部选择Runnable进行执行。既然我们有了思路，那我们就考虑一下所需要的数据结构？既然是从队列尾部插入Runnable对象，从队列头部...
java中线程的串行化简单举例
Rain
09-06 1541
在多线程程序中，如果在一个线程运行的过程中要用到另一个线程的运行结果，则可以进行线程的串行化处理 public final void join() throws      InterruptedException class MyRunner implements Runnable { public void run() { for(int i = 0; i < 10; i++)
CompletableFuture
学习之路
11-25 144
简介 Futrue CompletionStage 异步执行的一个阶段，这个阶段可能依赖另外一个Stage，在被依赖的Stage完成时触发。 Stage的计算可以根据是否需要参数和有无返回值采用Function，Consumer或者Runnable（使用方法比如apply，accept，run，比如 stage.thenApply(x -> square(x)) ...
java 串行线程_java线程
weixin_39809793的博客
02-12 201
线程串行单线程执行在食堂打饭的时候，食堂安排一个打饭大妈打饭，所有同学都排成一个队形，打饭大妈相当于线程，同学打饭相当于任务，这种一个大妈给一群站好队形的同同学打饭相当于java中的单线程串行执行任务。串行执行的缺点很明显，当一个同学选菜慢的情况下，效率低下，后面的同学早已不耐烦了并行多线程执行为了解决上述问题，食堂打算聘请和学生数目一样多的打饭大妈，同时给同学打饭，这样的话同学倒是开心了，很快就...
多线程线程池详解、 线程异步编排和线程串行化
suqinyi的博客
08-23 1622
多线程进阶 文章目录多线程进阶前言一、创建多线程的4种方式（回顾）1.1、创建线程1.2、区别1.3 总结二、线程池创建和说明1、自定义线程池1.1、7大参数说明1.2、自定义创建1.3、工作顺序1.4、案例思考2、Executors创建功能性线程池2.1、常见的四种功能性线程池2.2、创建定长线程池2.3、为什么使用线程池三、CompletableFuture异步编排和串行化1.1、CompletableFuture介绍1.2、2种创建方式 前言 多线程，可以先看下小编总结的多线程（一）基础篇==&g
Java（串行化）
JACK_JYH的博客
09-01 1820
对象的寿命通常随着生成该对象的程序终止而终止。某些时候，需要将对象的状态保存下来，将来需要的时候可以恢复。 把对象的这种记录自己状态以便将来再生的能力，叫做对象的持续性（persistence）。对象通过写出描述自己状态的数值来记录自己的过程，叫做对象的串行化（serialization） 串行化的主要任务是写出对象实例变量的数值。如果变量是另一个对象的引用，则引用的对象也要串行化。 Java
199、商城业务-异步-CompletableFuture-线程串行化
pyd1040201698的博客
09-07 212
CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> { System.out.println("当前线程：" + Thread.currentThread().getId()); int i = 10 / 2; System.out.println("运行结果：" + i); return...
可串行 线程池
sunweiliang的博客
08-14 681
基本的线程池如下图所示：          线程池的原理类似一个生产者-消费者的模式。生产者（一般是主线程/IO线程 ）将执行函数指针和要传递给函数的参数打包，然后放到任务队列里面；消费者（线程group） 从任务队列中取出任务，得到要执行的函数指针和函数参数，调用函数指针执行任务。执行完之后继续从任务队列里面获取任务。       线程池最大的优点就是多个任务并行执行，但不保证任务...
Java线程串行化详解与线程控制
线程串行化可以通过`Thread`类提供的`join()`方法实现，让一个线程等待另一个线程完成后再继续执行。`join()`方法有两个重载形式，分别允许指定等待的时间或者精确到纳秒的时间间隔。 线程是程序中的一个执行流，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员劝退师-TAO

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值