ThreadPoolTaskScheduler 定时如何等待任务执行完毕结束

在开发的过程中，特别是我们对数据进行处理的时候，我们经常会用到定时任务。

在这里我实现了一个可控的定时

我们可以在页面上添加定时任务，通过指定java的定时类，并且利用java反射可以后台运行的定时任务进行控制。但是现在存在一个问题，就是任务正在运行的过程中，我中断任务，那么这个任务是立刻被中断还是等待整个任务结束之后在进行中断。那么这个是根据我们任务的性质来确定。如何来进行实现，下面我们看代码：

@Autowired
    private ThreadPoolTaskScheduler threadPoolTaskScheduler;

    private static HashMap<String, ScheduledFuture<?>> map = new HashMap<String, ScheduledFuture<?>>();

    private ScheduledFuture<?> future;

    @Bean
    public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
        ThreadPoolTaskScheduler executor = new ThreadPoolTaskScheduler();
        return executor;
    }

    @PostConstruct
    public void init() {
        System.out.println("我指定了");
        List<AbsTaskInfo> list = taskService.getTaskList();
        for (AbsTaskInfo taskinfo : list) {
            if (taskinfo.getRunstatus() == 1 && map.get(taskinfo.getTaskclass()) == null) {
                try {
                    logger.info("开始启动定时任务：{}",taskinfo.getTaskname());
                    String taskclass = taskinfo.getTaskclass();
                    Class<?> clazz = Class.forName(taskclass);
                    HashMap<String, Object> hmap = new HashMap<String, Object>();
                    // hmap.put(ITaskStatusService.class.getName(), statusService);
                    // hmap.put(IUserToken.class.getName(),tokenService);
                    Constructor<?> con = clazz.getConstructor(Map.class);
                    future = threadPoolTaskScheduler.schedule((Runnable) con.newInstance(hmap),
                            new CronTrigger(taskinfo.getCronstr()));
                    map.put(taskclass, future);
                    taskinfo.setRestartflag(1);// 椤圭洰鍚姩涓惎鍔ㄦ垚鍔�
                    taskinfo.setRestarttime(new Date());
                    taskService.updateTaskInfo(taskinfo);
                } catch (ClassNotFoundException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (NoSuchMethodException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (SecurityException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (InstantiationException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IllegalArgumentException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        }

    }

    @ResponseBody
    @RequestMapping("/triggertask")
    public JSONObject triggerTask(@RequestBody Map<String, Object> reqMap) {
        try {
            String rowguid = reqMap.get("rowguid").toString();
            AbsTaskInfo taskinfo = taskService.getTaskInfoByGuid(rowguid);
            String taskclass = taskinfo.getTaskclass();
            if (taskinfo.getRunstatus() == 0) {
                logger.info("启动定时任务");
                Class<?> clazz = null;
                try {
                    clazz = Class.forName(taskclass);
                    HashMap<String, Object> hmap = new HashMap<String, Object>();
                    Constructor<?> con = clazz.getConstructor(Map.class);
                    future = threadPoolTaskScheduler.schedule((Runnable) con.newInstance(hmap),new CronTrigger(taskinfo.getCronstr()));
                    map.put(taskclass, future);
                    taskinfo.setRunstatus(1);
                    taskService.updateTaskInfo(taskinfo);
                    return BuildJsonOfObject.getJsonString("启动成功", MSG.SUCCESSCODE);
                } catch (Exception e) {
                    e.printStackTrace();
                    return BuildJsonOfObject.getJsonString(e.getMessage(), MSG.FAILCODE);

                }
            } else {
                logger.info("关闭定时任务");
                try {
                    future = map.get(taskclass);
                    
                    while (!future.isCancelled()) {
                        future.cancel(false);
                    }
                    if (future.isCancelled()) {
                        taskinfo.setRunstatus(0);
                        taskService.updateTaskInfo(taskinfo);
                        return BuildJsonOfObject.getJsonString("暂停成功", MSG.SUCCESSCODE);
                    }
                } catch (NullPointerException e) {
                    taskinfo.setRunstatus(0);
                    taskService.updateTaskInfo(taskinfo);
                }
            }
            return BuildJsonOfObject.getJsonString(MSG.SystemSuccess, MSG.SUCCESSCODE);
        } catch (Exception e) {
            e.printStackTrace();
            return BuildJsonOfObject.getJsonString(e.getMessage(), MSG.FAILCODE);
        }
    }

在这段代码中，基本上实现了对定时的控制，那么如何哪里是判断等待任务执行结束中断，还是直接中断定时任务

主要是代码：future.cancel(false);

这个函数接受的是一个boolean类型的，当我们传入true的时候就会直接中断定时任务

当传入false的时候，就会等待该线程执行结束之后结束定时任务

希望对你有所帮助