spring task 实现定时任务：动态暂停 恢复 修改和删除任务

以前是用spring+quartz的方式实现的定时任务：动态暂停 恢复 修改和删除任务。
但是在spring3以后，spring自己的task包，能实现轻量级的定时任务。
项目决定不用quartz，只用spring自带的包，完成这个任务。
我搜索了资料，发现很少有这方面的资料。求叫大神们，只用spring怎么实现以上要求。

你可以参考  Spring 3整合Quartz 2实现定时任务三：动态暂停 恢复 修改和删除任务 http://www.meiriyouke.net/?p=82

你可以 自己创建一张 记录task 表，task 计划表 和task 执行结果表,在创建一个定时任务 实时轮训task 表，创建task进行task,再创建一个定时任务,遍历task 计划表 查看是否有任务需要执行，执行结束后，删除task计划表的任务，同时把执行结果保存起来

亲，我就是不能用Quartz了。只用spring自己的jar包，来完成动态的定时任务。

忘记说了。临时不需要DB，只是简单的能实现动态任务就行~

楼主可以适当考虑一下bboss quartz任务管理框架，完全满足要求，参考资料：
http://yin-bp.iteye.com/category/333270

把任务抽象出来

其实很简单，在xml里配置一下schedule，然后在某个bean的方法中添加@Scheduled标注，根据cron的表达式设置定时即可，看看这个代码片段吧
http://tianmaying.com/snippet/8ab3eda84ce67d14014cebafd0440235

http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/#scheduling

官方详细文档说明

quartz 也是可以动态实现这个功能的.它还可以实现动态更新作业.改了class不用重启的那种.

spring task 大概就如下代码, 代码我没贴全,你自己参考吧,该用到的都在下面.可以完成你的功能

 /** logger日志. */
    public static final Logger LOGGER = Logger.getLogger(GTaskAssembler.class);
    private static final Map<String, GTask> TASKS = new HashMap<String, GTask>(12);
    private static final Map<String, ScheduledFuture<?>> SCHEDULED_FUTURE = new HashMap<String, ScheduledFuture<?>>(16);
    private final static int POOL_SIZE = 64;
    
    private final ConcurrentTaskScheduler ct = new ConcurrentTaskScheduler(Executors.newScheduledThreadPool(POOL_SIZE));
    
    /**
     * 启动一个计划任务.
     * @param task 当前进行的任务.
     */
    public void start(GTask task) {
        try {
            if (StringUtils.isEmpty(task.getTaskId())) {
                throw new GTaskException("the taskid must be not empty.");
            }

            if (StringUtils.isEmpty(task.getTrigger())) {
                throw new GTaskException("任务的调度表达式不能为空.");
            }

            ScheduledFuture<?> scheduledFuture = ct.schedule(task, new CronTrigger(task.getTrigger()));
            SCHEDULED_FUTURE.put(task.getTaskId(), scheduledFuture);
            TASKS.put(task.getTaskId(), task);
            LOGGER.info("the task with " + task.getTaskId() + "has bean already started.");
        } catch (Exception e) {
            LOGGER.info(null, e);
            throw new GTaskException(e);
        }
    }

    /**
     * 停止一个计划任务.
     * @param taskId 任务编号.
     */
    public void stop(String taskId) {
        LOGGER.info("正在停止任务 " + taskId);
        if (StringUtils.isEmpty(taskId)) {
            throw new GTaskException("the taskid must be not empty.");
        }

        try {
            ScheduledFuture<?> scheduledFuture = SCHEDULED_FUTURE.remove(taskId);
            if (scheduledFuture == null) {
                throw new GTaskException("the task with id " + taskId + " is not exists.");
            } else {
                if (!scheduledFuture.isCancelled()) {
                    /** false 表示当前任务若正在执行，则待其执行结束，再结束此任务. */
                    scheduledFuture.cancel(false);
                }
            }
        } catch (Exception e) {
            LOGGER.info(null, e);
            throw new GTaskException(e);
        }
    }

    /**
     * 重新设置当前任务的执行频率.
     * 
     * @param taskId
     *            任务编号.
     */
    public void resetTrigger(String taskId, String cronExpression) {
        LOGGER.info("正在修改当前任务 " + taskId + "执行频率.");
        if (StringUtils.isEmpty(taskId)) {
            throw new GTaskException("the taskid must be not empty.");
        }

        if (StringUtils.isEmpty(cronExpression)) {
            throw new GTaskException("任务的调度表达式不能为空.");
        }

        GTask task = TASKS.get(taskId);
        if (task != null) {
            if (cronExpression.equals(task.getTrigger())) {
                return;
            }

            /** first, stop the task. */
            ScheduledFuture<?> scheduledFuture = SCHEDULED_FUTURE.remove(taskId);
            scheduledFuture.cancel(false);

            /** second, reset the task with cronExpression. */
            task.setTrigger(cronExpression);
            /** third, restart the task. */
            scheduledFuture = ct.schedule(task, new CronTrigger(cronExpression));
            SCHEDULED_FUTURE.put(taskId, scheduledFuture);
        }
    }

    /**
     * 仅执行一次.
     * 
     * @param task 所要执行任务.
     */
    public void onlyOneTime(GTask task) {
        if (StringUtils.isEmpty(task.getTaskId())) {
            throw new GTaskException("the taskid must be not empty.");
        }

        ct.execute(task, 2000);
    }

    /**
     * 销毁线程池中的任务.
     */
    public void destrory() {
        LOGGER.info("正在终止自动任务的线程池资源.");
        ScheduledExecutorService scheduledExecutor = (ScheduledExecutorService) ct.getConcurrentExecutor();
        try {
            scheduledExecutor.shutdownNow();
        } catch (Exception e) {
            LOGGER.info("自动任务的线程池资源清理发生异常.", e);
        } finally {
            LOGGER.info("自动任务的线程池资源清理完成.");
        }
    }