`
longgangbai
  • 浏览: 7328434 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

Quartz的任务的临时启动和暂停和恢复

 
阅读更多

        在项目中需要手动启停某些服务,那么需要有一个控制这些任务的类。由于任务是有Quartz控制的,我们只需要通过Quartz的相关的API实现相关的功能即可。

      

package com.easyway.app.quartz.mgr;

import java.util.Date;
import java.util.List;
import java.util.Map;

import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.TriggerKey;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.matchers.GroupMatcher;

/**
 * 一个简单的quartz任务管理器
 * @author longgangbai
 *
 */
public class QuartzScheduleMgr {
	private static  Scheduler scheduler=getScheduler();
	/**
	 * 创建一个调度对象
	 * @return
	 * @throws SchedulerException
	 */
	private static Scheduler getScheduler() {
		    SchedulerFactory sf = new StdSchedulerFactory();
	        Scheduler scheduler=null;
			try {
				scheduler = sf.getScheduler();
			} catch (SchedulerException e) {
				e.printStackTrace();
			}
	        return scheduler;
	}
	public static Scheduler getInstanceScheduler(){
		return scheduler;
	}

	/**
	 * 启动一个调度对象
	 * @throws SchedulerException
	 */
	public  void start() throws SchedulerException
	{ 
		scheduler.start();
	}
    
    /**
     * 检查调度是否启动
     * @return
     * @throws SchedulerException
     */
	public  boolean isStarted() throws SchedulerException
	{
		return scheduler.isStarted();
	}

    /**
     * 关闭调度信息
     * @throws SchedulerException
     */
	public  void shutdown() throws SchedulerException	{
		scheduler.shutdown();
	}
    /**
     * 添加调度的job信息
     * @param jobdetail
     * @param trigger
     * @return
     * @throws SchedulerException
     */
	public  Date scheduleJob(JobDetail jobdetail, Trigger trigger)
			throws SchedulerException{
				return scheduler.scheduleJob(jobdetail, trigger); 
	}
    /**
     * 添加相关的触发器
     * @param trigger
     * @return
     * @throws SchedulerException
     */
	public  Date scheduleJob(Trigger trigger) throws SchedulerException{
		return scheduler.scheduleJob(trigger);
	}
	 /**
	  * 添加多个job任务
	  * @param triggersAndJobs
	  * @param replace
	  * @throws SchedulerException
	  */
	 public  void scheduleJobs(Map<JobDetail, List<Trigger>> triggersAndJobs, boolean replace) throws SchedulerException
	 {
		scheduler.scheduleJobs(triggersAndJobs, replace);
	}
    /**
     * 停止调度Job任务
     * @param triggerkey
     * @return
     * @throws SchedulerException
     */
	public  boolean unscheduleJob(TriggerKey triggerkey)
			throws SchedulerException{
		return scheduler.unscheduleJob(triggerkey);
	}

	/**
	 * 停止调度多个触发器相关的job
	 * @param list
	 * @return
	 * @throws SchedulerException
	 */
	public  boolean unscheduleJobs(List<TriggerKey> triggerKeylist) throws SchedulerException{
		return scheduler.unscheduleJobs(triggerKeylist);
	}
	/**
	 * 重新恢复触发器相关的job任务 
	 * @param triggerkey
	 * @param trigger
	 * @return
	 * @throws SchedulerException
	 */
	public  Date rescheduleJob(TriggerKey triggerkey, Trigger trigger)
	throws SchedulerException{
		return scheduler.rescheduleJob(triggerkey, trigger);
	}
	/**
	 * 添加相关的job任务
	 * @param jobdetail
	 * @param flag
	 * @throws SchedulerException
	 */
	public  void addJob(JobDetail jobdetail, boolean flag)
			throws SchedulerException	{
		scheduler.addJob(jobdetail, flag);
	}

	/**
	 * 删除相关的job任务
	 * @param jobkey
	 * @return
	 * @throws SchedulerException
	 */
	public  boolean deleteJob(JobKey jobkey) throws SchedulerException{
		return scheduler.deleteJob(jobkey);
	}

	/**
	 * 删除相关的多个job任务
	 * @param jobKeys
	 * @return
	 * @throws SchedulerException
	 */
	public     boolean deleteJobs(List<JobKey> jobKeys)
    throws SchedulerException{
		return scheduler.deleteJobs(jobKeys);
	}
    /**
     * 
     * @param jobkey
     * @throws SchedulerException
     */
	public  void triggerJob(JobKey jobkey) throws SchedulerException	{
		scheduler.triggerJob(jobkey);
	}
    /**
     * 
     * @param jobkey
     * @param jobdatamap
     * @throws SchedulerException
     */
	public  void triggerJob(JobKey jobkey, JobDataMap jobdatamap)
			throws SchedulerException	{
		scheduler.triggerJob(jobkey, jobdatamap);
	}
    /**
     * 停止一个job任务
     * @param jobkey
     * @throws SchedulerException
     */
	public  void pauseJob(JobKey jobkey) throws SchedulerException	{
		scheduler.pauseJob(jobkey);
	}
    /**
     * 停止多个job任务
     * @param groupmatcher
     * @throws SchedulerException
     */
	public  void pauseJobs(GroupMatcher<JobKey> groupmatcher)
			throws SchedulerException	{
		scheduler.pauseJobs(groupmatcher);
	}
    /**
     * 停止使用相关的触发器
     * @param triggerkey
     * @throws SchedulerException
     */
	public  void pauseTrigger(TriggerKey triggerkey)
			throws SchedulerException	{
		scheduler.pauseTrigger(triggerkey);
	}

	public  void pauseTriggers(GroupMatcher<TriggerKey> groupmatcher)
			throws SchedulerException	{
		scheduler.pauseTriggers(groupmatcher);
	}
    /**
     * 恢复相关的job任务
     * @param jobkey
     * @throws SchedulerException
     */
	public  void resumeJob(JobKey jobkey) throws SchedulerException	{
		scheduler.pauseJob(jobkey);
	}
    
	public  void resumeJobs(GroupMatcher<JobKey> matcher)
			throws SchedulerException	{
		scheduler.resumeJobs(matcher);
	}

	public  void resumeTrigger(TriggerKey triggerkey)
			throws SchedulerException	{
		scheduler.resumeTrigger(triggerkey);
	}
   
	public  void resumeTriggers(GroupMatcher<TriggerKey>  groupmatcher)
			throws SchedulerException
	{
		scheduler.resumeTriggers(groupmatcher);	
	}
    /**
     * 暂停调度中所有的job任务
     * @throws SchedulerException
     */
	public  void pauseAll() throws SchedulerException
	{
		scheduler.pauseAll();
	}
    /**
     * 恢复调度中所有的job的任务
     * @throws SchedulerException
     */
	public  void resumeAll() throws SchedulerException
	{
		scheduler.resumeAll();
	}
	
	
	
}

 

 

 

创建一个Job任务:

/* 
 * Copyright 2005 - 2009 Terracotta, Inc. 
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not 
 * use this file except in compliance with the License. You may obtain a copy 
 * of the License at 
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0 
 *   
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 
 * License for the specific language governing permissions and limitations 
 * under the License.
 * 
 */

package com.easyway.app.quartz.mgr;

import java.util.Date;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 * 一个简单的quartz调用job
 * @author longgangbai
 *
 */
public class HelloJob implements Job {

    private static Logger _log = LoggerFactory.getLogger(HelloJob.class);

    public HelloJob() {
    }

    public void execute(JobExecutionContext context)
        throws JobExecutionException {
        _log.info("Hello World! - " + new Date());
    }

}

 

 

创建触发器和调用相关的Job

/* 
 * Copyright 2005 - 2009 Terracotta, Inc. 
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not 
 * use this file except in compliance with the License. You may obtain a copy 
 * of the License at 
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0 
 *   
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 
 * License for the specific language governing permissions and limitations 
 * under the License.
 * 
 */

package com.easyway.app.quartz.mgr;

import static org.quartz.DateBuilder.evenMinuteDate;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.TriggerBuilder.newTrigger;

import java.util.Date;

import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.Trigger;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 一个简单的测试quartz任务管理器测试类
 * @author longgangbai
 *
 */
public class QuartzScheduleMain {

    
	/**
	 * 
	 * @throws Exception
	 */
    public void run() throws Exception {
        Logger log = LoggerFactory.getLogger(QuartzScheduleMain.class);

        log.info("------- Initializing ----------------------");

        // First we must get a reference to a scheduler
        //从调度管理器中获取调度对象
        Scheduler sched = QuartzScheduleMgr.getInstanceScheduler();
        log.info("------- Initialization Complete -----------");

        // computer a time that is on the next round minute
        Date runTime = evenMinuteDate(new Date());

        log.info("------- Scheduling Job  -------------------");

        // define the job and tie it to our HelloJob class
        //创建相关的job信息
        JobDetail job = newJob(HelloJob.class)
            .withIdentity("job1", "group1")
            .build();
        
        // Trigger the job to run on the next round minute
        //创建一个触发器的名称
        Trigger trigger = newTrigger()
            .withIdentity("trigger1", "group1")
            .startAt(runTime)
            .build();
        
        // Tell quartz to schedule the job using our trigger
        //设置调度相关的Job
        sched.scheduleJob(job, trigger);
        log.info(job.getKey() + " will run at: " + runTime);  

        // Start up the scheduler (nothing can actually run until the 
        // scheduler has been started)
        //启动调度任务
        sched.start();

        log.info("------- Started Scheduler -----------------");

        try {
            Thread.sleep(25L * 1000L); 
            // executing...
        } catch (Exception e) {
        }
        //暂时停止Job任务开始执行
        log.info("-------pauseJob.. -------------");
        sched.pauseJob(job.getKey());
        
        try {
            Thread.sleep(10L * 1000L); 
        } catch (Exception e) {
        }
        log.info("------- resumeJob... -------------");
        //恢复Job任务开始执行
        sched.resumeJob(job.getKey());
        try {
            Thread.sleep(10L * 1000L); 
            // executing...
        } catch (Exception e) {
        }
        
        
        // wait long enough so that the scheduler as an opportunity to 
        // run the job!
        log.info("------- Waiting 65 seconds... -------------");
        try {
            // wait 65 seconds to show job
            Thread.sleep(65L * 1000L); 
            // executing...
        } catch (Exception e) {
        }

        // shut down the scheduler
        log.info("------- Shutting Down ---------------------");
        sched.shutdown(true);
        log.info("------- Shutdown Complete -----------------");
    }

    public static void main(String[] args) throws Exception {

        QuartzScheduleMain example = new QuartzScheduleMain();
        example.run();

    }

}

 

分享到:
评论
6 楼 mengfei86 2014-08-14  
adezuo 写道
/**
     * 停止一个job任务
     * @param jobkey
     * @throws SchedulerException
     */ 
    public  void pauseJob(JobKey jobkey) throws SchedulerException  { 
        scheduler.pauseJob(jobkey); 
    } 

我再测试中发现,使用这种方式停止一个Job任务后,当前任务还是继续执行完毕,不知为何?

比如计划执行5次,当执行到第二次的过程中,手动停止此任务,可是第2次还是正常执行完毕,第三次没有启动。

楼主是否碰到此类问题,如何停止当前正在执行的任务?

这个任务就是一个激发过程,。。开始之后就不受他的控制了,他只管之后的任务不让激发了。  也就是他帮助启动了一个线程执行你要执行的代码。。代码执行过程中他是没法控制的。  希望对你有所帮助
5 楼 adezuo 2014-08-08  
/**
     * 停止一个job任务
     * @param jobkey
     * @throws SchedulerException
     */ 
    public  void pauseJob(JobKey jobkey) throws SchedulerException  { 
        scheduler.pauseJob(jobkey); 
    } 

我再测试中发现,使用这种方式停止一个Job任务后,当前任务还是继续执行完毕,不知为何?

比如计划执行5次,当执行到第二次的过程中,手动停止此任务,可是第2次还是正常执行完毕,第三次没有启动。

楼主是否碰到此类问题,如何停止当前正在执行的任务?
4 楼 aqingtian005 2014-05-30  
首先感谢楼主的分享

最近在项目上使用Quartz做任务调度,需要手动来管理Job,如是挖坟挖到这里来了,LZ的代码给了我很大的其实,后来结合Spring通过Job代理的方式实现了动态添加Job(POJO,并非配置在Spring中),完成了需求。最后在测试Job暂停和恢复事,死活恢复不了,浪费我一下午的时间去排错,甚至怀疑Spring的bug

问题在这里:
/**
     * 恢复相关的job任务
     * @param jobkey
     * @throws SchedulerException
     */ 
    public  void resumeJob(JobKey jobkey) throws SchedulerException { 
        scheduler.pauseJob(jobkey); 
    }

3 楼 kingasdfg 2014-03-11  
首先感谢分享,但是发现还有一些不够完善的地方
在测试例子里,有方法的创建,启动 暂停等
但是如果任务调度没有执行完,在这个过程中去停止对于业务逻辑会产生很糟糕的影响,应该去添加一些状态判断

2 楼 0564long 2013-04-28  
1 楼 mengfei86 2013-01-22  

相关推荐

    Spring Quartz 动态暂停、恢复、修改定时任务

    Spring Quartz 动态暂停、恢复、修改定时任务的一个demo,使用maven构建,框架采用spring springmvc jpa,数据库mysql,含数据库脚本,运行可用,页面访问地址http://localhost:8080/quartz_demo/quartz/list

    ssm整合quartz定时任务实现动态增删改查,暂停任务,恢复任务

    ssm整合quartz 并持久化到数据库中,实现动态增删改查,暂停任务,恢复任务等 将链接内的target文件直接放到项目ssmquartztest文件夹下 运行环境: jdk5+tomcat7+mysql+eclipse+maven lib jar包下载地址 地址1:...

    spring和quartz的定时器的启动和停止例子

    通过以上步骤,我们可以灵活地在Spring应用中使用Quartz实现定时任务的启动和停止。在实际项目中,还可以根据需求对任务进行分组、优先级排序、任务依赖设置等高级功能,以满足复杂的调度需求。记得在生产环境中,...

    Spring 3整合Quartz 1.8实现定时任务三:动态暂停 恢复 修改和删除任务

    Spring 3整合Quartz 1.8实现定时任务三:动态暂停 恢复 修改和删除任务 任务保存到数据库,系统启动时读取数据库,页面显示加载,并管理 注:spring3+quartz2动态任务调度,任务保存在内存中,页面显示动态管理版...

    Quartz任务调度器

    同时,Quartz提供了丰富的API和插件系统,可以进行更复杂的任务调度,如暂停、恢复、删除任务,以及动态修改任务执行策略等。 总的来说,Quartz任务调度器与Spring的整合使得我们能够在应用中轻松地实现定时任务的...

    ssm整合quartz定时任务实现动态增删改查,暂停任务,恢复任务lib jar包下载

    ssm整合quartz 并持久化到数据库中,实现动态增删改查,暂停任务,恢复任务等 将链接内的target文件直接放到项目ssmquartztest文件夹下 运行环境: jdk5+tomcat7+mysql+eclipse+maven lib jar包下载

    定时任务quartz实现分组串行并行动态配置

    Quartz提供了API接口和JMX支持,可以获取Job和Trigger的状态,以及进行暂停、恢复、删除等操作。 7. **持久化存储**:Quartz支持多种持久化策略,如内存、数据库等。选择合适的存储方式可以确保在服务器重启后仍能...

    quartz 随tomcat启动执行一次

    通过对题目中提供的信息进行分析,我们可以了解到如何利用 Spring 与 Quartz 进行集成,从而实现 Tomcat 启动时调用 Quartz 执行一次任务的需求。通过合理配置 `SchedulerFactoryBean`、`CronTriggerBean` 和 `...

    Quartz.net作业调度自定义定时执行任务多任务执行c#

    6. **持久化**: 为了保证任务的可靠性和在服务器重启后的恢复,Quartz.NET支持数据库等持久化存储。这样,即使应用程序停止,任务信息也不会丢失。 7. **错误处理和监控**: 你可以设置监听器(`JobListener`和`...

    Quartz调度、终止执行的任务

    关于终止执行的任务,Quartz提供了`scheduler.pauseJob()`和`scheduler.resumeJob()`方法来暂停和恢复Job。如果你想要终止某个任务,你可以调用`scheduler.deleteJob()`来移除Job实例,使其不再执行。例如: ```...

    quartz动态任务管理

    Quartz是一款开源的作业调度框架,它允许开发者创建、调度和执行各种类型的任务。这个"quartz动态任务管理"源码包很可能是针对Quartz框架的实现,旨在帮助开发者更方便地管理和控制任务的生命周期。 Quartz的核心...

    java quartz 定时任务

    通过`org.quartz.Scheduler`接口,可以启动、暂停、恢复和删除任务。 8. **BrpTask**: - "BrpTask"可能是项目中一个具体的任务类或任务模块。这个类可能实现了`Job`接口,并且有对应的CronTrigger来定义其执行...

    Quartz任务监控管理

    8. **Web界面**:为了方便操作和监控,项目可能提供了一个Web界面,用户可以通过这个界面来查看任务列表、添加新任务、修改任务配置、启动或停止任务等。 9. **性能优化**:监控管理不仅需要展示任务信息,还需要...

    任务管理API quartz

    通过Scheduler实例,你可以安排任务、启动、暂停、恢复或删除任务。 4. Calendar:日历接口用于定义时间范围,例如节假日或周末不执行任务。 二、开发指南 在使用Quartz时,开发者通常需要遵循以下步骤: 1. 创建...

    quartz任务调度使用手册

    - `standby()`和`start()`方法可以暂停和恢复整个Scheduler的执行。 - `unscheduleJob()`用于取消已安排的任务。 7. **监控和日志**: - Quartz提供了一个Web管理界面(JMX支持),可以查看和控制任务状态。 - ...

    quartZ定时任务.zip

    - 对于大量任务,可以使用`scheduler.pauseAll()`和`scheduler.resumeAll()`来暂停或恢复所有任务。 6. **监控和调试** - Quartz提供了Web管理界面(如`QuartzAdmin`),可以通过界面查看、修改和控制任务。 - ...

    C# Quartz.Net定时任务操作明细、完整过程

    【C# Quartz.Net定时任务操作】Quartz.Net是一款强大的任务调度框架,广泛应用于C#环境下的定时任务管理。本文将详细介绍如何使用Quartz.Net进行定时任务的配置与执行。 首先,**通过Nuget安装框架**非常简单,只需...

    C# 控制台Quartz定时任务.doc

    总结来说,Quartz.NET是C#中实现定时任务的强大工具,通过创建和配置Scheduler、Job、JobDetail和Trigger,开发者可以灵活地控制任务的执行。在控制台应用中,Quartz.NET使得定时任务的管理和执行变得简单且高效。

    Spring 3整合Quartz 2实现定时任务三:动态暂停 恢复 修改和删除任务

    Spring 3整合Quartz 2实现定时任务三:动态暂停 恢复 修改和删除任务,原http://blog.csdn.net/phantomes/article/details/37880551博客的源码例子

    Quartz定时任务框架

    通过Scheduler接口,你可以启动、停止、暂停和恢复调度。 2. Job:Job代表了要执行的任务。你需要定义一个实现了`org.quartz.Job`接口的类,并重写`execute(JobExecutionContext context)`方法来编写实际的业务逻辑...

Global site tag (gtag.js) - Google Analytics