Java实现异步的几种方式

自由的羽毛  金牌会员 | 2024-2-18 22:40:25 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 595|帖子 595|积分 1785


  • 普通线程实现异步，但频繁创建、销毁线程比较耗资源，所以一般交给线程池执行
    1. //创建需要异步执行的逻辑
    2. public class AsyncThread implements Runnable{
    3.     @Override
    4.     public void run() {
    5.         System.out.println("异步线程开始");
    6.         long start = System.currentTimeMillis();
    7.         try {
    8.             TimeUnit.SECONDS.sleep(3);
    9.         } catch (InterruptedException e) {
    10.             throw new RuntimeException(e);
    11.         }
    12.         long end = System.currentTimeMillis();
    13.         System.out.println("异步线程：" + Thread.currentThread().getName() + "结束，耗时：" + (end - start));
    14.     }
    15. }
    17. //在业务中进行调用
    18. @GetMapping("/thread")
    19. public String asyncThread(){
    20.     ThreadPoolExecutor threadPool = new ThreadPoolExecutor(3, 3, 5, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10), new ThreadPoolExecutor.AbortPolicy());
    21.     long start = System.currentTimeMillis();
    22.     //自己的业务代码。。。
    23.     AsyncThread asyncThread = new AsyncThread();
    24.     threadPool.execute(asyncThread);
    25.     long end = System.currentTimeMillis();
    26.     return "返回,耗时:" + (end - start);
    27. }
    复制代码
    结果：
  • Future异步

    和普通线程实现异步区别不大，只是使用Future是要获取执行后的返回值
    1. //创建具有返回值的任务
    2. public class CallableThread implements Callable {
    3.     @Override
    4.     public String call() throws Exception {
    5.         long start = System.currentTimeMillis();
    6.         StopWatch stopWatch = new StopWatch();
    7.         stopWatch.start();
    8.         System.out.println("callable任务开始执行:" + start);
    9.         TimeUnit.SECONDS.sleep(2);
    10.         System.out.println();
    11.         stopWatch.stop();
    12.         System.out.println("stopWatch.prettyPrint------");
    13.         System.out.println(stopWatch.prettyPrint());
    14.         System.out.println("stopWatch.shortSummary------");
    15.         System.out.println(stopWatch.shortSummary());
    16.         System.out.println("stopWatch.getTotalTimeMillis------");
    17.         System.out.println(stopWatch.getTotalTimeMillis());
    18.         return "call执行结束 ";
    19.     }
    20. }
    22. //在业务中进行调用
    23. public String threadFuture(){
    24.     ThreadPoolExecutor threadPool = new ThreadPoolExecutor(3, 3, 5, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10), new ThreadPoolExecutor.AbortPolicy());
    25.     long start = System.currentTimeMillis();
    26.     CallableThread callableThread = new CallableThread();
    27.     Future<String> submit = threadPool.submit(callableThread);
    28.     try {
    29.         //在获取返回值时会阻塞主线程
    30.         String s = "";
    31.         s = submit.get();
    32.         System.out.println(s);
    33.     } catch (Exception e) {
    34.         System.out.println("线程运行发生错误" + e.getMessage());
    35.         throw new RuntimeException(e);
    36.     }
    37.     long end = System.currentTimeMillis();
    38.     return "接口返回,耗时:" + (end - start);
    39. }
    复制代码
    结果：
  • Spring的@Async异步

    • 使用@Async注解实现异步的前提是需要在启动类上标注@EnableAsync来开启异步配置
    • 配置线程池（@Async默认情况下用的是SimpleAsyncTaskExecutor线程池，该线程池不是真正意义上的线程池，使用此线程池无法实现线程重用，每次调用都会新建一条线程。若系统中不断的创建线程，最终会导致系统占用内存过高，引发OutOfMemoryError错误）
      1. /**
      2. * 线程池配置，可以配置多个线程池
      3. * @Async注解，默认使用系统自定义线程池，可在项目中设置多个线程池，在异步调用的时候，指明需要调用的线程池名称
      4. * 比如：@Async("线程池1")
      5. */
      6. @Configuration
      7. public class ExecutorConfig {
      8.     /**
      9.      * 自定义线程池
      10.      */
      11.     @Bean("myExecutor")
      12.     public Executor taskExecutor(){
      13.         System.out.println("系统最大线程数:" + Runtime.getRuntime().availableProcessors());
      14.         ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
      15.         threadPoolTaskExecutor.setCorePoolSize(8);//核心线程数
      16.         threadPoolTaskExecutor.setMaxPoolSize(16);//最大线程数
      17.         threadPoolTaskExecutor.setQueueCapacity(1000);//配置队列容量
      18.         threadPoolTaskExecutor.setKeepAliveSeconds(60);//空闲线程存活时间
      19.         threadPoolTaskExecutor.setThreadNamePrefix("myExecutor-");//线程名字前缀
      20.         return threadPoolTaskExecutor;
      21.     }
      22. }
      复制代码
    • 编写异步方法的逻辑，异步方法所在的类需要被Spring管理
      1. @Service
      2. public class AsyncServiceImpl implements AsyncService {
      3.     @Override
      4.     @Async("myExecutor")
      5.     public void sendMsg() {
      6.         System.out.println("进入异步方法");
      7.         System.out.println("当前线程名称：" + Thread.currentThread().getName());
      8.         try {
      9.             TimeUnit.SECONDS.sleep(2);
      10.         } catch (InterruptedException e) {
      11.             throw new RuntimeException(e);
      12.         }
      13.         System.out.println("异步方法执行完成");
      14.     }
      16.     /**
      17.      * 具有返回值的异步方法，返回类型为Future,返回时new 一个AsyncResult对象，其中参数为返回的内容
      18.      * @return
      19.      */
      20.     @Override
      21.     @Async("myExecutor")
      22.     public Future<String> sendMsgFuture() {
      23.         System.out.println("进入future异步方法");
      24.         try {
      25.             TimeUnit.SECONDS.sleep(2);
      26.         } catch (InterruptedException e) {
      27.             throw new RuntimeException(e);
      28.         }
      29.         return new AsyncResult<>("future异步方法执行完成");
      30.     }
      31. }
      复制代码
    • 在业务逻辑中调用
      1. @GetMapping("/asyncMethod")
      2. public String asyncMethod(){
      3.     System.out.println("aaa");
      4.     System.out.println("调用异步方法");
      5.     asyncService.sendMsg();
      6.     System.out.println("bbb");
      7.     return "asyncMethod方法返回";
      8. }
      复制代码
      调用没有返回值的异步方法结果：
      1. @GetMapping("/asyncFutureMethod")
      2. public String asyncFutureMethod(){
      3.     System.out.println("aaa");
      4.     Future<String> stringFuture = asyncService.sendMsgFuture();
      5.     System.out.println("bbb");
      6.     try {
      7.     System.out.println(stringFuture.get());//get方法会阻塞主线程
      8.     } catch (Exception e) {
      9.     throw new RuntimeException(e);
      10.     }
      11.     return "asyncfutureMethod方法返回";
      12. }
      复制代码
      调用有返回值的异步方法结果：

  • Spring的ApplicationEvent事件实现异步

    • 定义事件，继承ApplicationEvent类
      1. public class MessageEvent extends ApplicationEvent {
      2.     @Getter
      3.     private String message;
      5.     public MessageEvent(Object source, String message) {
      6.         super(source);
      7.         this.message = message;
      8.     }
      9. }
      复制代码
    • 定义监听器（需要被Spring管理）
      使用@EventListener注解写在方法上定义一个监听器，即事件被触发时执行的方法(默认是同步执行，可以使用@Async注解标注为异步执行)，支持多个监听器监听同一个事件。
      1. @Component
      2. public class MessageEventHandler {
      4.     //@Async
      5.     @EventListener
      6.     public void handleLoginEvent(LoginEvent event){
      7.         System.out.println("接受到LoginEvent事件");
      8.         try {
      9.             TimeUnit.SECONDS.sleep(2);
      10.         } catch (InterruptedException e) {
      11.             throw new RuntimeException(e);
      12.         }
      13.         System.out.println(event.getUsername());
      14.         System.out.println("LoginEvent事件处理完成");
      15.     }
      17.     //@Async
      18.     @EventListener
      19.     public void handleMessageEvent(MessageEvent event){
      20.         System.out.println("接受到MessageEvent事件");
      21.         try {
      22.             TimeUnit.SECONDS.sleep(2);
      23.         } catch (InterruptedException e) {
      24.             throw new RuntimeException(e);
      25.         }
      26.         System.out.println(event.getMessage());
      27.         System.out.println("MessageEvent事件处理完成");
      28.     }
      29. }
      复制代码
    • 定义事件发布者(触发事件的)（需要被Spring管理）
      实现ApplicationEventPublisherAware接口
      1. @Component
      2. public class EventPublisher implements ApplicationEventPublisherAware {
      3.     private ApplicationEventPublisher publisher;
      5.     @Override
      6.     public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
      7.         this.publisher = applicationEventPublisher;
      8.     }
      10.     public void publish(ApplicationEvent event){
      11.         if (event instanceof MessageEvent){
      12.             System.out.println("开始发布MessageEvent事件:" + ((MessageEvent) event).getMessage());
      13.         } else if (event instanceof LoginEvent) {
      14.             System.out.println("开始发布LoginEvent事件:" + ((LoginEvent) event).getUsername());
      15.         }
      16.         //发布事件
      17.         publisher.publishEvent(event);
      18.         System.out.println("事件发布结束");
      19.     }
      21. }
      复制代码
    • 业务代码执行时触发事件
      1. @GetMapping("/pubEvent")
      2. public String publishEvent(){
      3.     System.out.println("业务逻辑开始");
      4.     eventPublisher.publish(new MessageEvent(this,"testEvent"));
      5.     System.out.println("业务逻辑结束");
      6.     return "发布成功";
      7. }
      复制代码
      执行结果：
      由控制台打印可以发现现在事件监听器方法的执行是同步的，如果需要异步执行，在监听器方法上加个@Async注解即可，但使用Async注解的前提是在启动类上标注@EnableAsync注解来开启异步配置
      使用@Async注解后执行结果：
      可以看到监听器中的打印在最后了，证明是异步执行的


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

自由的羽毛

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表