Spring Boot使用@Async异步多个结果集合并

小灰灰 2023-10-07 13:38 9阅读 0赞

以我的搜索功能为例，多个搜索结果合并

异步类：AsyncService

import java.util.concurrent.Future;
    
    import org.springframework.scheduling.annotation.Async;
    import org.springframework.scheduling.annotation.AsyncResult;
    import org.springframework.stereotype.Service;
    
    @Service
    public class AsyncService {
    	/**
    	 * 应用搜索-异步
    	 */
    	@Async
    	public Future<String> searchAppInfo() throws Exception{
    		//自己的业务逻辑
    				
    		//睡眠3秒测试		
    		Thread.sleep(3000);	
    		
    		String result = null;
    		return new AsyncResult<String>(result);
    	}
    	
    	/**
    	 * 待办搜索-异步
    	 */
    	@Async
    	public Future<String> searchPending() throws Exception{
    		//自己的业务逻辑
    				
    		//睡眠1秒测试		
    		Thread.sleep(1000);	
    		
    		String result = null;
    		return new AsyncResult<String>(result);
    	}
    	
    	/**
    	 * 用户搜索-异步
    	 */
    	@Async
    	public Future<String> searchUser() throws Exception{
    		//自己的业务逻辑
    				
    		//睡眠2秒测试		
    		Thread.sleep(2000);	
    		
    		String result = null;
    		return new AsyncResult<String>(result);
    	}
    }

业务类：CompositeService

import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.Future;
    import java.util.concurrent.TimeUnit;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    @Service
    public class CompositeService {
    	@Autowired
        private AsyncService asyncService;
    	
    	/**
    	 * 综合搜索集合
    	 */
    	public Map<String, String> searchList() {
    		try {
    			long beforeTime = System.currentTimeMillis();// 开始时间戳
    			
    			//应用搜索-异步
    			Future<String> appResult = asyncService.searchAppInfo();
    			//待办搜索-异步
    			Future<String> pendingResult = asyncService.searchPending();
    			//用户搜索-异步
    			Future<String> userResult = asyncService.searchUser();
    
    			
    			//添加结果集，30秒超时
    			Map<String, String> jsonObject = new HashMap<String, String>();
    			if(appResult != null){
    				jsonObject.put("AppInfo", appResult.get(30, TimeUnit.SECONDS));
    			}
    			if(pendingResult != null){
    				jsonObject.put("AppPending", pendingResult.get(30, TimeUnit.SECONDS));
    			}
    			if(userResult != null){
    				jsonObject.put("UnifiedUser", userResult.get(30, TimeUnit.SECONDS));
    			}
    			
    			long afterTime = System.currentTimeMillis();// 结束时间戳
    			//耗时3秒多正确，耗时6秒多异步未成功
    			System.out.println("耗时"+(afterTime - beforeTime)+"毫秒");
    			
    			return jsonObject;
    		} catch (Exception e) {
    			e.printStackTrace();
    			return null;
    		}	
    	}
    }

调用测试：ControllerTest

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import com.async.service.CompositeService;
    
    /**
     * 测试异步任务
     */
    @RestController
    public class ControllerTest {
        @Autowired
        private CompositeService compositeService;
        
        @GetMapping("/test")
        public String test(){
            compositeService.searchList();
            return "异步测试...............";
        }
    }

打印结果，应该为3秒多，因为休眠的时间最长的一个方法是3秒

耗时3011毫秒

如果有打印出6秒多，证明有问题，实在解决不了的，可以使用笨一点的办法，修改业务类CompositeService代码

import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.Future;
    import java.util.concurrent.TimeUnit;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    @Service
    public class CompositeService {
    	@Autowired
        private AsyncService asyncService;
    	
    	/**
    	 * 综合搜索集合
    	 */
    	public Map<String, String> searchList() {
    		try {
    			long beforeTime = System.currentTimeMillis();// 开始时间戳
    			
    			//应用搜索-异步
    			Future<String> appResult = asyncService.searchAppInfo();
    			//待办搜索-异步
    			Future<String> pendingResult = asyncService.searchPending();
    			//用户搜索-异步
    			Future<String> userResult = asyncService.searchUser();
    
    			//循环判断所有异步方法是否执行完毕
    			long beforeTime1 = System.currentTimeMillis();// 开始时间戳
    			while (true) {
    				//执行完毕跳出循环
    				if((appResult == null || appResult.isDone()) 
    						&& (pendingResult == null || pendingResult.isDone())
    						&& (userResult == null || userResult.isDone())){
    					break;
    				}
    				//超时跳出循环
    				long afterTime1 = System.currentTimeMillis();// 结束时间戳
    				if((afterTime1 - beforeTime1) > 30000){	//30秒
    					break;
    				}
    				Thread.sleep(20);	//每隔20毫秒执行一次
    			}
    			
    			//添加结果集，30秒超时
    			Map<String, String> jsonObject = new HashMap<String, String>();
    			if(appResult != null){
    				jsonObject.put("AppInfo", appResult.get());
    			}
    			if(pendingResult != null){
    				jsonObject.put("AppPending", pendingResult.get());
    			}
    			if(userResult != null){
    				jsonObject.put("UnifiedUser", userResult.get());
    			}
    			
    			long afterTime = System.currentTimeMillis();// 结束时间戳
    			//耗时3秒多正确，耗时6秒多异步未成功
    			System.out.println("耗时"+(afterTime - beforeTime)+"毫秒");
    			
    			return jsonObject;
    		} catch (Exception e) {
    			e.printStackTrace();
    			return null;
    		}	
    	}
    }

使用循环判断Future类自带的方法isDone()判断是否执行完毕

//循环判断所有异步方法是否执行完毕
    			long beforeTime1 = System.currentTimeMillis();// 开始时间戳
    			while (true) {
    				//执行完毕跳出循环
    				if((appResult == null || appResult.isDone()) 
    						&& (pendingResult == null || pendingResult.isDone())
    						&& (userResult == null || userResult.isDone())){
    					break;
    				}
    				//超时跳出循环
    				long afterTime1 = System.currentTimeMillis();// 结束时间戳
    				if((afterTime1 - beforeTime1) > 30000){	//30秒
    					break;
    				}
    				Thread.sleep(20);	//每隔20毫秒执行一次
    			}