异步那些事01

最新推荐文章于 2024-06-14 15:02:13 发布
最新推荐文章于 2024-06-14 15:02:13 发布
阅读量955 收藏 13
点赞数 27
文章标签： java 异步 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72410274/article/details/139216219
版权

首先我们肯定先说创建线程

1.继承Thread类

o定义一个类MyThread继承Thread类
o在MyThread类中重写run()方法
o创建MyThread类的对象
o启动线程

package Java.thread;

public class first extends  Thread{
    public  void run(){
        for(int i=0;i<50;i++){
            System.out.println("我是小线程"+"名称："+getName()+"，运行结果："+i);
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}


package Java.thread;

public class test {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("我是主线程");
        first f1=new first();
        first f2=new first();
        f1.start();
        f2.start();
        Thread.sleep(50);
        System.out.println("主线程结果。");
    }
}

请添加图片描述
2.实现Runnable接口

o定义一个类MyRunnable实现Runnable接口
o在MyRunnable类中重写run()方法
o创建MyRunnable类的对象
o创建Thread类的对象，把MyRunnable对象作为构造方法的参数
o启动线程

package Java.thread;

public class second implements Runnable{
    public void run(){
        for(int i=0;i<50;i++){
        //不能直接获取getname，因为不是继承
            System.out.println("我是小线程"+"名称："+Thread.currentThread().getName()+"，运行结果："+i);
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


package Java.thread;

public class test {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("我是主线程");
   second s1=new second();
   second s2=new second();
   Thread t=new Thread(s1,"小线程1");
   Thread t1=new Thread(s2,"小线程2");
   t.start();
   t1.start();
   Thread.sleep(50);
   System.out.println("主线程结果。");
    }
}

请添加图片描述
使用lambda简化：

package Java.thread;

public class test {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("我是主线程");
        Runnable s1=()->{
            for(int i=0;i<50;i++){
            //不能直接获取getname，因为不是继承
            System.out.println("我是小线程"+"名称："+Thread.currentThread().getName()+"，运行结果："+i);
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }};
   Thread t=new Thread(s1,"小线程1");
   Thread t1=new Thread(s1,"小线程2");
   t.start();
   t1.start();
   Thread.sleep(50);
   System.out.println("主线程结果。");
    }
}

3.实现Callable接口

  • V call() 计算结果，如果无法计算结果，则抛出一个异常
  • FutureTask(Callable callable) 创建一个
    FutureTask，一旦运行就执行给定的 Callable
  • V get() 如有必要，等待计算完成，然后获取其结果

o定义一个类MyCallable实现Callable接口
o在MyCallable类中重写call()方法
o创建MyCallable类的对象
o创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
o创建Thread类的对象，把FutureTask对象作为构造方法的参数
o启动线程
o再调用get方法，就可以获取线程结束之后的结果。

package Java.thread;

import java.util.concurrent.Callable;

public class thired implements Callable {
    @Override
    public Object call() throws Exception {
        for(int i=0;i<50;i++){
            System.out.println("我是小线程"+"名称："+Thread.currentThread().getName()+"，运行结果："+i);
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        String o="callable";
        return o;
    }
}


public class test {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
   thired s1=new thired();
   thired s2=new thired();
   FutureTask f1=new FutureTask(s1);
   FutureTask f2=new FutureTask(s2);
   Thread t=new Thread(f1,"小线程1");
   Thread t1=new Thread(f2,"小线程2");
   t.start();
   t1.start();
   System.out.println("小线程1结果"+f1.get());
   System.out.println("小线程2结果"+f2.get());
   System.out.println("主线程结果。");
    }
}

请添加图片描述
System.out.println(“主线程结果。”); 并不是在所有其他线程都完成之后才执行的，而是取决于 f1.get() 和 f2.get() 的调用顺序和它们的行为。
FutureTask.get() 方法用于获取异步计算的结果。如果计算尚未完成，此方法将阻塞直到它完成。这意味着，如果 f1 或 f2 对应的线程尚未完成其任务，get() 方法将阻塞主线程，直到该任务完成。
主线程会首先等待 f1 完成，然后再等待 f2 完成。

o实现Runnable、Callable接口
o好处: 扩展性强，实现该接口的同时还可以继承其他的类
o缺点: 编程相对复杂，不能直接使用Thread类中的方法
o继承Thread类
o好处: 编程比较简单，可以直接使用Thread类中的方法
o缺点: 可以扩展性较差，不能再继承其他的类

CompletableFuture引入

Future有几个局限，Java1.8就推出了加强版的Future类：CompletableFuture。

来上几个future的局限的代码（部分，下一节重点是completablefuture）：
1.阻塞主进程的执行：


public class test {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //自定义线程池 ,使用自定义的拒绝策略
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 4, 60,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(5));
           Callable callable=()->{
               System.out.println(Thread.currentThread().getName()+":任务执行中");
               Thread.sleep(600);
               return "任务执行完成";
           };

           Future f=threadPoolExecutor.submit(callable);
           System.out.println("任务执行中");
           System.out.println(f.get());
           System.out.println("阻塞我的主进程了吗？？？，我看看");
           threadPoolExecutor.shutdown();
    }
}

请添加图片描述

改为completableFuture:

import java.util.concurrent.*;

public class test {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //自定义线程池 ,使用自定义的拒绝策略
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 4, 60,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(5));
           Callable callable=()->{
               System.out.println(Thread.currentThread().getName()+":任务执行中");
               Thread.sleep(600);
               return "任务执行完成";
           };

      CompletableFuture<String> completableFuture=  CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread().getName()+":任务执行中");
          try {
              Thread.sleep(600);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          return "任务执行完成";

        },threadPoolExecutor);
        //注册一个回调函数来处理结果
        completableFuture.thenAccept(re-> {
            System.out.println("任务完成结果："+re);
        });
        System.out.println("其他进程执行中");
        threadPoolExecutor.shutdown();
    }


}

请添加图片描述

2.链式调用上：

futuretask不能链式调用，任务2无法用任务1的结果


public class test {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //自定义线程池 ,使用自定义的拒绝策略
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 4, 60,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(5));

         Future <String> future=threadPoolExecutor.submit(()->{
             try {
                 Thread.sleep(60);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             return "任务1完成";
         });

         Future <String> future1=threadPoolExecutor.submit(()->{
             //我们想要在这个任务中使用 future 的结果，但我们不能直接链式调用
             try {
                 Thread.sleep(60);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             return "任务2完成";
         });

        System.out.println(future.get());
        System.out.println(future1.get());
        threadPoolExecutor.shutdown();
    }


}

completablefuture:


public class test {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //自定义线程池 ,使用自定义的拒绝策略
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 4, 60,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(5));

          CompletableFuture<String> completableFuture=CompletableFuture.supplyAsync(()->{
              try {
                  Thread.sleep(60);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              return "任务1完成";
          },threadPoolExecutor);


         CompletableFuture<String> completableFuture1=completableFuture.thenApplyAsync(re->{
             //我们想要在这个任务中使用 future 的结果，但我们不能直接链式调用
             try {
                 Thread.sleep(60);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             return "任务2完成并用了任务1的结果:"+re;
         },threadPoolExecutor);

        completableFuture.thenAccept(re->{
            System.out.println("任务1运行结果:"+re);
        });
        completableFuture1.thenAccept(re1->{
            System.out.println("r任务2运行结果："+re1);
        });

        System.out.println("主线程的任务3");

    }

请添加图片描述

星星不说话01
关注
【Spring Boot 3】异步线程任务
又言又语
01-29 897
本文介绍开发Spring Boot应用实现异步线程任务的方法及步骤。Spring Boot使用注解开启对异步线程的支持，使用@Async注解标注异步任务，@Async注解在类上，则该类中所有方法都是异步线程执行，需要注意使用@Async注解的类对象必须是Spring上下文管理的Bean实例；注解在方法上，只有标注注解的方法是异步线程执行。Spring异步任务的原理是通过Spring AOP动态代理实现的，Spring容器初始化Bean实例时会扫描@Async。
异步线程池
qq_54516125的博客
05-08 3682
异步&线程池 1、初始化线程的4种方式 2，线程池的七大参数 3，Executors中常见四种线程池 4，开发中为什么使用线程池 CompletableFuture异步编排 1创建异步对象 2计算完成时回调方法 3handle方法 4线程串行化方法 5两任务组合-都要完成 6两个任务组合-一个完成 7多任务组合
01 Java中的异步回调
m0_46836425的博客
05-07 3470
有时候我们执行一个任务需要很长时间，单线程环境下 会处于阻塞状态，严重影响效率，那么可以使用一种非阻塞的处理方式，这就是使用多线程。 多线程情况下，问题出来了，我们不知道线程什么时候执行完毕，或者不知道如何处理子线程的结果，那么就有以下两种方式：异步回调和同步等待线程处理结果两种方式 1. 异步回调 直接上代码，固定格式：主业务代码和一个处理结果的接口 /** * Callback * 回调一般是异步处理的一种技术。 * 一个回调是被传递到并且执行完该方法。 这种方式只能异步回调， * 如果需要同步
异步任务的四种方式
华小灼
02-22 3478
1. 继承Thread public class TestDemo { public static void main(String[] args) { System.out.println("main...start...."); new Thread01().start(); System.out.println("main...end...."); } /** * 继承Thread */ public
JavaScript异步编程——01-单线程和异步任务
——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
05-06 825
史诗级JavaScript异步编程学习，快来订阅专栏吧！
delphi异步与javascript
pulledup的博客
12-09 1059
本文提纲挈领地概述了网络请求的异步模型和同步模型应用、代码示例，及其跨平台的c的API库的底层的实现原理；在delphi和c中使用javascrpt时的多线程话题
JavaScript：异步函数
JinsmLill的博客
10-18 3777
通过在函数定义前使用关键字 async ，定义异步函数。定义异步函数// 命名函数 async function asyncFunc_01() {} // 匿名函数 const asyncFunc_02 = async function() {} // 箭头函数 const asyncFunc_03 = async() => {}
APC异步过程调用
kernweak的博客
09-03 2402
线程是不能被“杀掉”、“挂起”、“恢复”的，线程在执行的时候自己占据着CPU,别人怎么可能控制它呢？ 举个极端的例子：如果不调用API,屏蔽中断,并保证代码不出现异常，线程将永久占用CPU，何谈控制呢?所以说线程如果想“死”，一定是自己执行代码把自己杀死，不存在“他杀”这种情况！ 那如果想改变一个线程的行为该怎么办呢? 可以给他提供一个函数，让它自己去调用，这个函数就是APC(Asyncro...
Java发起同异步HTTP请求和处理数据
weixin_42077074的博客
03-16 3797
笔者做了个简单的测试，测试方案如下，一个 JSON 对象对应数据表中的一条记录，对象含有两个键，取值分别为长度为 10 的和长度为 1000 的随机字符串，记录不同方案、不同请求量级下请求获取数据的耗时。然而， 大多数情况下，一次请求是对应多条记录的，返回内容中会有数组让你遍历，而且在你处理异步请求结果之前，你并不知道一个请求对应多少记录，也就未知总记录数。每次仅将一部分的异步请求发起并处理结果，一旦当前记录数达到页面大小就立即异步请求，随后将当前页所有异步请求的结果再分页处理。
Python异步编程入门
千山暮彩
07-24 985
带你初步认识Python异步编程模型
异步电机直接转矩控制
05-02
毕业设计异步电机直接转矩控制系统MATLAB Simulink
异步调用实例01-EndInvoke-c#
09-21
直接调用EndInvoke 方法等待异步调用结束 异步执行方法的最简单的方式是通过调用委托的BeginInvoke方法来开始执行方法，在主线程上执行一些工作，然后调用委托的EndInvoke方法。EndInvoke可能会阻止调用线程，因为它...
C# 编写的TCP异步服务器代码
01-07
代码采用C#编写，服务器采用异步方式，带有测试的例子。
js高级01-同步异步问题.md
11-28
js高级01-同步异步问题.md
Python 携程_异步IO 01协程的概念.mp4
02-09
Python 携程_异步IO 01协程的概念.mp4
【仿真建模-anylogic】FlowchartPort原理解析
zhaoyaxuan001的博客
06-14 294
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
Spring Boot集成antlr实现词法和语法分析
HBLOG
06-13 869
Antlr4 是一款强大的语法生成器工具，可用于读取、处理、执行和翻译结构化的文本或二进制文件。基本上是当前 Java 语言中使用最为广泛的语法生成器工具。Twitter搜索使用ANTLR进行语法分析，每天处理超过20亿次查询；Hadoop生态系统中的Hive、Pig、数据仓库和分析系统所使用的语言都用到了ANTLR；Lex Machina将ANTLR用于分析法律文本；Oracle公司在SQL开发者IDE和迁移工具中使用了ANTLR；NetBeans公司的IDE使用ANTLR来解析C++；
盲盒App开发时有哪些技术框架可以借鉴
最新发布
bytekj的博客
06-14 510
在开发盲盒App时，可以根据项目需求和团队技术栈选择合适的技术框架。前端可以选择微信小程序框架、React Native或Vue.js等；后端可以选择Node.js或Spring Boot等；数据库可以选择MySQL或MongoDB等。同时，还需要考虑缓存、消息队列、支付和物流接口等其他技术来完善应用的功能和性能。
【Java02】Java中数组的定义与初始化
饮冰室
06-10 590
推荐第一种方式。这种方式容易让人理解，数据类型是type[]，对象名称是arrayName。第二种方式有些老旧了。由于数组是一种引用变量（也就是一个指针），所以定义的时候还没有指向任何有效的内存空间，因此在定义数组的时候不能指定数组的长度，也不能直接使用。必须进行初始化。可以使用var让系统自动推断变量类型，既可以用于静态初始化，也可以用于动态初始化。
unity异步加载场景
07-09
注意，在异步加载的过程中，进度会达到0.9，因此我们使用`Mathf.Clamp01`来将进度限制在0-0.9之间。 最后，使用`yield return null`来等待一帧的时间，然后再次循环检查加载进度。当加载进度达到1时，表示场景加载...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值