良许Linux教程网 干货合集 详解Java异步调用

详解Java异步调用

在长期的Java客户端开发中,最常见的一个客户端调用模式就是Java的异步调用。所谓异步调用其实就是实现一个可无需等待被调用函数的返回值而让操作继续运行的方法。在Java语言中,简单的讲就是另启一个线程来完成调用中的部分计算,使调用继续运行或返回,而不需要等待计算结果。

img

一、创建线程

@Test
public void test0() throws Exception {
 System.out.println("main函数开始执行");
 Thread thread=new Thread(new Runnable() {
   @Override
   public void run() {
     System.out.println("===task start===");
     try {
       Thread.sleep(5000);
     } catch (InterruptedException e) {
       e.printStackTrace();
     }
     System.out.println("===task finish===");
   }
 });

 thread.start();
 System.out.println("main函数执行结束");

}

二、Future

jdk8之前的实现方式,在JUC下增加了Future,从字面意思理解就是未来的意思,但使用起来却着实有点鸡肋,并不能实现真正意义上的异步,获取结果时需要阻塞线程,或者不断轮询。

@Test
public void test1() throws Exception {

   System.out.println("main函数开始执行");

   ExecutorService executor = Executors.newFixedThreadPool(1);
   Future future = executor.submit(new Callable() {
       @Override
       public Integer call() throws Exception {

           System.out.println("===task start===");
           Thread.sleep(5000);
           System.out.println("===task finish===");
           return 3;
       }
   });
   //这里需要返回值时会阻塞主线程,如果不需要返回值使用是OK的。倒也还能接收
   //Integer result=future.get();
   System.out.println("main函数执行结束");

   System.in.read();

}

三、CompletableFuture

使用原生的CompletableFuture实现异步操作,加上对lambda的支持,可以说实现异步任务已经发挥到了极致。

@Test
public void test2() throws Exception {
   System.out.println("main函数开始执行");
   ExecutorService executor = Executors.newFixedThreadPool(2);
   CompletableFuture future = CompletableFuture.supplyAsync(new Supplier() {
       @Override
       public Integer get() {
           System.out.println("===task start===");
           try {
               Thread.sleep(5000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           System.out.println("===task finish===");
           return 3;
       }
   }, executor);
   future.thenAccept(e -> System.out.println(e));
   System.out.println("main函数执行结束");
}

四、Spring的Async注解

使用spring实现异步需要开启注解,可以使用xml方式或者Java config的方式。

xml方式:

"executor" />
"executor"
       pool-size="2" 线程池的大小
       queue-capacity="100" 排队队列长度
       keep-alive="120" 线程保活时间(单位秒)
       rejection-policy="CALLER_RUNS" 对拒绝的任务处理策略 />

java方式:

@EnableAsync
public class MyConfig {

   @Bean
   public TaskExecutor executor(){
       ThreadPoolTaskExecutor executor=new ThreadPoolTaskExecutor();
       executor.setCorePoolSize(10); //核心线程数
       executor.setMaxPoolSize(20);  //最大线程数
       executor.setQueueCapacity(1000); //队列大小
       executor.setKeepAliveSeconds(300); //线程最大空闲时间
       executor.setThreadNamePrefix("fsx-Executor-"); //指定用于新创建的线程名称的前缀。
       executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
       return executor;
   }
}

(1)@Async

@Test
public void test3() throws Exception {
   System.out.println("main函数开始执行");
   myService.longtime();
   System.out.println("main函数执行结束");
}

@Async
public void longtime() {
   System.out.println("我在执行一项耗时任务");
   try {
       Thread.sleep(5000);
   } catch (InterruptedException e) {
       e.printStackTrace();
   }
   System.out.println("完成");

}

(2)AsyncResult

如果需要返回值,耗时方法返回值用AsyncResult包装。

@Test
public void test4() throws Exception {
   System.out.println("main函数开始执行");
   Future future=myService.longtime2();
   System.out.println("main函数执行结束");
   System.out.println("异步执行结果:"+future.get());
}

@Async
public Future longtime2() {
   System.out.println("我在执行一项耗时任务");

   try {
       Thread.sleep(8000);
   } catch (InterruptedException e) {
       e.printStackTrace();
   }

   System.out.println("完成");
   return new AsyncResult(3);
}

以上就是良许教程网为各位朋友分享的Linux系统相关内容。想要了解更多Linux相关知识记得关注公众号“良许Linux”,或扫描下方二维码进行关注,更多干货等着你 !

img
本文由 良许Linux教程网 发布,可自由转载、引用,但需署名作者且注明文章出处。如转载至微信公众号,请在文末添加作者公众号二维码。
良许

作者: 良许

良许,世界500强企业Linux开发工程师,公众号【良许Linux】的作者,全网拥有超30W粉丝。个人标签:创业者,CSDN学院讲师,副业达人,流量玩家,摄影爱好者。
上一篇
下一篇

发表评论

联系我们

联系我们

公众号:良许Linux

在线咨询: QQ交谈

邮箱: yychuyu@163.com

关注微信
微信扫一扫关注我们

微信扫一扫关注我们

关注微博
返回顶部