三十三、Spring Boot实现异步调用

Dear 丶 2022-05-17 03:53 213阅读 0赞

\#                          Spring Boot实现异步调用

开启异步调用：

package com.yang;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.scheduling.annotation.EnableAsync;
    import org.springframework.scheduling.annotation.EnableScheduling;
    
    @SpringBootApplication
    @EnableScheduling//开启定时任务
    @EnableAsync//开启异步调用
    public class DubboSpringBootApplication {
    
    	public static void main(String[] args) {
    		SpringApplication.run(DubboSpringBootApplication.class, args);
    	}
    }

声明可被异步调用的方法：

package com.yang.task;
    
    import java.util.concurrent.Future;
    
    import org.springframework.scheduling.annotation.Async;
    import org.springframework.scheduling.annotation.AsyncResult;
    import org.springframework.stereotype.Component;
    
    @Component
    public class AsyncTask {
    	//@Async所修饰的函数不要定义为static类型，这样异步调用不会生效
    	//异步回调不返回数据
    	@Async
    	public void dealNoReturnTask(){
    		
    		System.out.println("Thread {} deal No Return Task start"
    		                    + "    "
    				            +Thread.currentThread().getName());
    		try {
    		    Thread.sleep(3000);
    		} catch (InterruptedException e) {
    		    e.printStackTrace();
    		}
    		System.out.println("Thread {} deal No Return Task end at {}"+"    "
    		                    +Thread.currentThread().getName()+"    "
    				            +System.currentTimeMillis());
    	 }
    	
    	
    	
    	//异步回调返回数据
    	@Async
    	public Future<String> dealHaveReturnTask() {
    		try {
    		    Thread.sleep(3000);
    		} catch (InterruptedException e) {
    		    e.printStackTrace();
    		}		
    		return new AsyncResult<String>("异步回调返回数据！");
    	}
    }

测试：

//不带返回值的异步回调
     asyncTask.dealNoReturnTask();
      try {
      	    System.out.println("begin to deal other Task!");
        Thread.sleep(10000);
      } catch (InterruptedException e) {
       e.printStackTrace();
      }
      
      
    //带返回值的异步回调
    //用future.get()来获取异步任务的返回结果
    Future<String> future = asyncTask.dealHaveReturnTask();
    System.out.println("begin to deal other Task!");
     while (true) {
      if(future.isCancelled()){
    	  System.out.println("deal async task is Cancelled");
          break;
      }
      if (future.isDone() ) {
    	  System.out.println("deal async task is Done");
    	  System.out.println("return result is " + future.get());
          break;
      }
      System.out.println("wait async task to end ...");
      Thread.sleep(1000);
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2JpZV85MDc0ODY4NTI_size_16_color_FFFFFF_t_70_pic_center][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2JpZV85MDc0ODY4NTI_size_16_color_FFFFFF_t_70_pic_center]: /images/20220517/fb718a27790d474ab508cd4a66d19288.png