持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第12天，点击查看活动详情
为什么要管理异步任务
异步任务执行，我们并不能快熟的得到他的运行结果，这就导致我们很多时候没办法对异步任务进行的运行状况有一个很好的掌控，这里我们就是解决异步任务的这一问题。
自定义异步任务线程池，异步任务异常捕获处理器
首先我们要自定义异步任务线程池，以及异步任务异常捕获器
import org.apache.commons.lang3.time.StopWatch;
/**
* <h1>自定义异步任务线程池，异步任务异常捕获处理器 </h1>
*/
@Slf4j
@EnableAsync //开启Spring异步任务支持
@Configuration
public class AsyncPoolConfig implements AsyncConfigurer {
/**
* <h2>将自定义的线程池注入到 Spring 容器中</h2>
* */
@Bean
@Override
public Executor getAsyncExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(10);
executor.setMaxPoolSize(20);
executor.setQueueCapacity(20);
executor.setKeepAliveSeconds(60);
executor.setThreadNamePrefix("Qinyi-Async-"); // 这个非常重要
// 等待所有任务结果候再关闭线程池
executor.setWaitForTasksToCompleteOnShutdown(true);
executor.setAwaitTerminationSeconds(60);
// 定义拒绝策略
executor.setRejectedExecutionHandler(
new ThreadPoolExecutor.CallerRunsPolicy()
);
// 初始化线程池, 初始化 core 线程
executor.initialize();
return executor;
}
/**
* <h2>指定系统中的异步任务在出现异常时使用到的处理器</h2>
* */
@Override
public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
return new AsyncExceptionHandler();
}
/**
* <h2>异步任务异常捕获处理器</h2>
* */
@SuppressWarnings("all")
class AsyncExceptionHandler implements AsyncUncaughtExceptionHandler {
@Override
public void handleUncaughtException(Throwable throwable, Method method,
Object... objects) {
throwable.printStackTrace();
log.error("Async Error: [{}], Method: [{}], Param: [{}]",
throwable.getMessage(), method.getName(),
JSON.toJSONString(objects));
// TODO 发送邮件或者是短信, 做进一步的报警处理
}
}
}
编写对应的异步任务
在需要异步处理的方法上，标注@Async("getAsyncExecutor")就可以开启异步任务,getAsyncExecutor就是之前自定义的异步任务线程池。示例：
/**
* <h1>异步服务接口实现</h1>
* */
@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
public class AsyncServiceImpl implements IAsyncService {
private final IUserService userService;
public AsyncServiceImpl(IUserService userService) {
this.userService = userService;
}
@Override
@Async("getAsyncExecutor")
public void asyncImportUser(List<UserReq> goodsInfos, String taskId) {
log.info("async task running taskId: [{}]", taskId);
StopWatch watch = StopWatch.createStarted();
userService.saveBatch(CopyUtil.copyList(goodsInfos, User.class));
watch.stop();
log.info("check and import goods success: [{}ms]",
watch.getTime(TimeUnit.MILLISECONDS));
}
}
我们并不直接使用异步方法，需要对异步方法进行一些管理与监控
异步任务的管理
创建用于异步管理的类
/**
* <h1>异步任务执行信息</h1>
* */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class AsyncTaskInfo {
/** 异步任务 id */
private String taskId;
/** 异步任务开始时间 */
private Date startTime;
/** 异步任务结束时间 */
private Date endTime;
/** 异步任务总耗时 */
private String totalTime;
}
定义用于异步管理的枚举
/**
* <h1>异步任务状态枚举</h1>
* */
@Getter
@AllArgsConstructor
public enum AsyncTaskStatusEnum {
STARTED(0, "已经启动"),
RUNNING(1, "正在运行"),
SUCCESS(2, "执行成功"),
FAILED(3, "执行失败"),
;
/** 执行状态编码 */
private final int state;
/** 执行状态描述 */
private final String stateInfo;
}
异步任务执行管理器
我们就是通过这个类去间接的调用异步任务，从而对异步任务的一些状态进行记录。
/**
* <h1>异步任务执行管理器</h1>
* 对异步任务进行包装管理, 记录并塞入异步任务执行信息
* */
@Slf4j
@Component
public class AsyncTaskManager {
/** 异步任务执行信息容器，这里作为演示，使用的map，可以使用mysql之类的做持久化 */
private final Map<String, AsyncTaskInfo> taskContainer =
new HashMap<>(16);
private final IAsyncService asyncService;
public AsyncTaskManager(IAsyncService asyncService) {
this.asyncService = asyncService;
}
/**
* <h2>初始化异步任务</h2>
* */
public AsyncTaskInfo initTask() {
AsyncTaskInfo taskInfo = new AsyncTaskInfo();
// 设置一个唯一的异步任务 id, 只要唯一即可
taskInfo.setTaskId(UUID.randomUUID().toString());
taskInfo.setStatus(AsyncTaskStatusEnum.STARTED);
taskInfo.setStartTime(new Date());
// 初始化的时候就要把异步任务执行信息放入到存储容器中
taskContainer.put(taskInfo.getTaskId(), taskInfo);
return taskInfo;
}
/**
* <h2>提交异步任务</h2>
* */
public AsyncTaskInfo submit(List<GoodsInfo> goodsInfos) {
// 初始化一个异步任务的监控信息
AsyncTaskInfo taskInfo = initTask();
asyncService.asyncImportGoods(goodsInfos, taskInfo.getTaskId());
return taskInfo;
}
/**
* <h2>设置异步任务执行状态信息</h2>
* */
public void setTaskInfo(AsyncTaskInfo taskInfo) {
taskContainer.put(taskInfo.getTaskId(), taskInfo);
}
/**
* <h2>获取异步任务执行状态信息</h2>
* */
public AsyncTaskInfo getTaskInfo(String taskId) {
return taskContainer.get(taskId);
}
}
使用AOP实现对异步任务的监控
/**
* <h1>异步任务执行监控切面</h1>
* */
@Slf4j
@Aspect
@Component
public class AsyncTaskMonitor {
/** 注入异步任务管理器 */
private final AsyncTaskManager asyncTaskManager;
public AsyncTaskMonitor(AsyncTaskManager asyncTaskManager) {
this.asyncTaskManager = asyncTaskManager;
}
/**
* <h2>异步任务执行的环绕切面</h2>
* 环绕切面让我们可以在方法执行之前和执行之后做一些 "额外" 的操作
* */
@Around("execution(* com.taluohui.ecommerce.service.async.AsyncServiceImpl.*(..))")
public Object taskHandle(ProceedingJoinPoint proceedingJoinPoint) {
// 获取 taskId, 调用异步任务传入的第二个参数
String taskId = proceedingJoinPoint.getArgs()[1].toString();
// 获取任务信息, 在提交任务的时候就已经放入到容器中了
AsyncTaskInfo taskInfo = asyncTaskManager.getTaskInfo(taskId);
log.info("AsyncTaskMonitor is monitoring async task: [{}]", taskId);
taskInfo.setStatus(AsyncTaskStatusEnum.RUNNING);
asyncTaskManager.setTaskInfo(taskInfo); // 设置为运行状态, 并重新放入容器
AsyncTaskStatusEnum status;
Object result;
try {
// 执行异步任务
result = proceedingJoinPoint.proceed();
status = AsyncTaskStatusEnum.SUCCESS;
} catch (Throwable ex) {
// 异步任务出现了异常
result = null;
status = AsyncTaskStatusEnum.FAILED;
log.error("AsyncTaskMonitor: async task [{}] is failed, Error Info: [{}]",
taskId, ex.getMessage(), ex);
}
// 设置异步任务其他的信息, 再次重新放入到容器中
taskInfo.setEndTime(new Date());
taskInfo.setStatus(status);
taskInfo.setTotalTime(String.valueOf(
taskInfo.getEndTime().getTime() - taskInfo.getStartTime().getTime()
));
asyncTaskManager.setTaskInfo(taskInfo);
return result;
}
}
Controller
/**
* <h1>异步任务服务对外提供的 API</h1>
* */
@Api(tags = "商品异步入库服务")
@Slf4j
@RestController
@RequestMapping("/async-goods")
public class AsyncGoodsController {
private final AsyncTaskManager asyncTaskManager;
public AsyncGoodsController(AsyncTaskManager asyncTaskManager) {
this.asyncTaskManager = asyncTaskManager;
}
@ApiOperation(value = "导入商品", notes = "导入商品进入到商品表", httpMethod = "POST")
@PostMapping("/import-goods")
public AsyncTaskInfo importGoods(@RequestBody List<GoodsInfo> goodsInfos) {
return asyncTaskManager.submit(goodsInfos);
}
@ApiOperation(value = "查询状态", notes = "查询异步任务的执行状态", httpMethod = "GET")
@GetMapping("/task-info")
public AsyncTaskInfo getTaskInfo(@RequestParam String taskId) {
return asyncTaskManager.getTaskInfo(taskId);
}
}
