java.lang.Object
- org.quartz.core.QuartzScheduler

All Implemented Interfaces:

java.rmi.Remote, RemotableQuartzScheduler
```
public class QuartzScheduler
extends java.lang.Object
implements RemotableQuartzScheduler
```
This is the heart of Quartz, an indirect implementation of the Scheduler interface, containing methods to schedule Jobs, register JobListener instances, etc.

Author:

James House

See Also:

Scheduler, QuartzSchedulerThread, JobStore, ThreadPool

Constructor Summary

Constructors
Constructor	Description
`QuartzScheduler(QuartzSchedulerResources resources, long idleWaitTime, long dbRetryInterval)`	Create a `QuartzScheduler` with the given configuration properties.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`addCalendar(java.lang.String calName, Calendar calendar, boolean replace, boolean updateTriggers)`	Add (register) the given `Calendar` to the Scheduler.
`void`	`addInternalJobListener(JobListener jobListener)`	Add the given `JobListener` to the `Scheduler`'s internal list.
`void`	`addInternalSchedulerListener(SchedulerListener schedulerListener)`	Register the given `SchedulerListener` with the `Scheduler`'s list of internal listeners.
`void`	`addInternalTriggerListener(TriggerListener triggerListener)`	Add the given `TriggerListener` to the `Scheduler`'s internal list.
`void`	`addJob(JobDetail jobDetail, boolean replace)`	Add the given `Job` to the Scheduler - with no associated `Trigger`.
`void`	`addJob(JobDetail jobDetail, boolean replace, boolean storeNonDurableWhileAwaitingScheduling)`
`void`	`addNoGCObject(java.lang.Object obj)`
`boolean`	`checkExists(JobKey jobKey)`	Determine whether a `Job` with the given identifier already exists within the scheduler.
`boolean`	`checkExists(TriggerKey triggerKey)`	Determine whether a `Trigger` with the given identifier already exists within the scheduler.
`void`	`clear()`	Clears (deletes!) all scheduling data - all `Job`s, `Trigger`s `Calendar`s.
`boolean`	`deleteCalendar(java.lang.String calName)`	Delete the identified `Calendar` from the Scheduler.
`boolean`	`deleteJob(JobKey jobKey)`	Delete the identified `Job` from the Scheduler - and any associated `Trigger`s.
`boolean`	`deleteJobs(java.util.List<JobKey> jobKeys)`
`Calendar`	`getCalendar(java.lang.String calName)`	Get the `Calendar` instance with the given name.
`java.util.List<java.lang.String>`	`getCalendarNames()`	Get the names of all registered `Calendars`.
`java.util.List<JobExecutionContext>`	`getCurrentlyExecutingJobs()`	Return a list of `JobExecutionContext` objects that represent all currently executing Jobs in this Scheduler instance.
`JobListener`	`getInternalJobListener(java.lang.String name)`	Get the internal `JobListener` that has the given name.
`java.util.List<JobListener>`	`getInternalJobListeners()`	Get a List containing all of the `JobListener`s in the `Scheduler`'s internal list.
`java.util.List<SchedulerListener>`	`getInternalSchedulerListeners()`	Get a List containing all of the internal `SchedulerListener`s registered with the `Scheduler`.
`TriggerListener`	`getInternalTriggerListener(java.lang.String name)`	Get the internal `TriggerListener` that has the given name.
`java.util.List<TriggerListener>`	`getInternalTriggerListeners()`	Get a list containing all of the `TriggerListener`s in the `Scheduler`'s internal list.
`JobDetail`	`getJobDetail(JobKey jobKey)`	Get the `JobDetail` for the `Job` instance with the given name and group.
`JobFactory`	`getJobFactory()`
`java.util.List<java.lang.String>`	`getJobGroupNames()`	Get the names of all known `Job` groups.
`java.util.Set<JobKey>`	`getJobKeys(GroupMatcher<JobKey> matcher)`	Get the names of all the `Jobs` in the matching groups.
`java.lang.Class<?>`	`getJobStoreClass()`
`ListenerManager`	`getListenerManager()`
`org.slf4j.Logger`	`getLog()`
`java.util.Set<java.lang.String>`	`getPausedTriggerGroups()`
`SchedulerContext`	`getSchedulerContext()`	Returns the `SchedulerContext` of the `Scheduler`.
`java.lang.String`	`getSchedulerInstanceId()`	Returns the instance Id of the `QuartzScheduler`.
`java.lang.String`	`getSchedulerName()`	Returns the name of the `QuartzScheduler`.
`SchedulerSignaler`	`getSchedulerSignaler()`
`java.lang.ThreadGroup`	`getSchedulerThreadGroup()`	Returns the name of the thread group for Quartz's main threads.
`java.lang.Class<?>`	`getThreadPoolClass()`
`int`	`getThreadPoolSize()`
`Trigger`	`getTrigger(TriggerKey triggerKey)`	Get the `Trigger` instance with the given name and group.
`java.util.List<java.lang.String>`	`getTriggerGroupNames()`	Get the names of all known `Trigger` groups.
`java.util.Set<TriggerKey>`	`getTriggerKeys(GroupMatcher<TriggerKey> matcher)`	Get the names of all the `Triggers` in the matching groups.
`java.util.List<? extends Trigger>`	`getTriggersOfJob(JobKey jobKey)`	Get all `Trigger` s that are associated with the identified `JobDetail`.
`Trigger.TriggerState`	`getTriggerState(TriggerKey triggerKey)`	Get the current state of the identified `Trigger`.
`java.lang.String`	`getVersion()`
`static java.lang.String`	`getVersionIteration()`
`static java.lang.String`	`getVersionMajor()`
`static java.lang.String`	`getVersionMinor()`
`void`	`initialize()`
`boolean`	`interrupt(java.lang.String fireInstanceId)`	Interrupt the identified InterruptableJob executing in this Scheduler instance.
`boolean`	`interrupt(JobKey jobKey)`	Interrupt all instances of the identified InterruptableJob executing in this Scheduler instance.
`boolean`	`isClustered()`
`boolean`	`isInStandbyMode()`	Reports whether the `Scheduler` is paused.
`boolean`	`isShutdown()`	Reports whether the `Scheduler` has been shutdown.
`boolean`	`isShuttingDown()`
`boolean`	`isSignalOnSchedulingChange()`
`boolean`	`isStarted()`
`void`	`notifyJobListenersToBeExecuted(JobExecutionContext jec)`
`void`	`notifyJobListenersWasExecuted(JobExecutionContext jec, JobExecutionException je)`
`void`	`notifyJobListenersWasVetoed(JobExecutionContext jec)`
`protected void`	`notifyJobStoreJobComplete(OperableTrigger trigger, JobDetail detail, Trigger.CompletedExecutionInstruction instCode)`
`protected void`	`notifyJobStoreJobVetoed(OperableTrigger trigger, JobDetail detail, Trigger.CompletedExecutionInstruction instCode)`
`void`	`notifySchedulerListenersError(java.lang.String msg, SchedulerException se)`
`void`	`notifySchedulerListenersFinalized(Trigger trigger)`
`void`	`notifySchedulerListenersInStandbyMode()`
`void`	`notifySchedulerListenersJobAdded(JobDetail jobDetail)`
`void`	`notifySchedulerListenersJobDeleted(JobKey jobKey)`
`void`	`notifySchedulerListenersPausedJob(JobKey key)`
`void`	`notifySchedulerListenersPausedJobs(java.lang.String group)`
`void`	`notifySchedulerListenersPausedTrigger(TriggerKey triggerKey)`
`void`	`notifySchedulerListenersPausedTriggers(java.lang.String group)`
`void`	`notifySchedulerListenersResumedJob(JobKey key)`
`void`	`notifySchedulerListenersResumedJobs(java.lang.String group)`
`void`	`notifySchedulerListenersResumedTrigger(TriggerKey key)`
`void`	`notifySchedulerListenersResumedTriggers(java.lang.String group)`
`void`	`notifySchedulerListenersSchduled(Trigger trigger)`
`void`	`notifySchedulerListenersShutdown()`
`void`	`notifySchedulerListenersShuttingdown()`
`void`	`notifySchedulerListenersStarted()`
`void`	`notifySchedulerListenersStarting()`
`void`	`notifySchedulerListenersUnscheduled(TriggerKey triggerKey)`
`protected void`	`notifySchedulerThread(long candidateNewNextFireTime)`
`void`	`notifyTriggerListenersComplete(JobExecutionContext jec, Trigger.CompletedExecutionInstruction instCode)`
`boolean`	`notifyTriggerListenersFired(JobExecutionContext jec)`
`void`	`notifyTriggerListenersMisfired(Trigger trigger)`
`int`	`numJobsExecuted()`
`void`	`pauseAll()`	Pause all triggers - equivalent of calling `pauseTriggers(GroupMatcher)` with a matcher matching all known groups.
`void`	`pauseJob(JobKey jobKey)`	Pause the `JobDetail` with the given name - by pausing all of its current `Trigger`s.
`void`	`pauseJobs(GroupMatcher<JobKey> groupMatcher)`	Pause all of the `JobDetails` in the matching groups - by pausing all of their `Trigger`s.
`void`	`pauseTrigger(TriggerKey triggerKey)`	Pause the `Trigger` with the given name.
`void`	`pauseTriggers(GroupMatcher<TriggerKey> matcher)`	Pause all of the `Triggers` in the matching groups.
`boolean`	`removeInternalJobListener(java.lang.String name)`	Remove the identified `JobListener` from the `Scheduler`'s list of internal listeners.
`boolean`	`removeInternalSchedulerListener(SchedulerListener schedulerListener)`	Remove the given `SchedulerListener` from the `Scheduler`'s list of internal listeners.
`boolean`	`removeinternalTriggerListener(java.lang.String name)`	Remove the identified `TriggerListener` from the `Scheduler`'s list of internal listeners.
`boolean`	`removeNoGCObject(java.lang.Object obj)`
`java.util.Date`	`rescheduleJob(TriggerKey triggerKey, Trigger newTrigger)`	Remove (delete) the `Trigger` with the given name, and store the new given one - which must be associated with the same job.
`void`	`resetTriggerFromErrorState(TriggerKey triggerKey)`
`void`	`resumeAll()`	Resume (un-pause) all triggers - equivalent of calling `resumeTriggerGroup(group)` on every group.
`void`	`resumeJob(JobKey jobKey)`	Resume (un-pause) the `JobDetail` with the given name.
`void`	`resumeJobs(GroupMatcher<JobKey> matcher)`	Resume (un-pause) all of the `JobDetails` in the matching groups.
`void`	`resumeTrigger(TriggerKey triggerKey)`	Resume (un-pause) the `Trigger` with the given name.
`void`	`resumeTriggers(GroupMatcher<TriggerKey> matcher)`	Resume (un-pause) all of the `Triggers` in the matching groups.
`java.util.Date`	`runningSince()`
`void`	`scheduleJob(JobDetail jobDetail, java.util.Set<? extends Trigger> triggersForJob, boolean replace)`
`java.util.Date`	`scheduleJob(JobDetail jobDetail, Trigger trigger)`	Add the `Job` identified by the given `JobDetail` to the Scheduler, and associate the given `Trigger` with it.
`java.util.Date`	`scheduleJob(Trigger trigger)`	Schedule the given `Trigger` with the `Job` identified by the `Trigger`'s settings.
`void`	`scheduleJobs(java.util.Map<JobDetail,java.util.Set<? extends Trigger>> triggersAndJobs, boolean replace)`
`void`	`setJobFactory(JobFactory factory)`
`void`	`setSignalOnSchedulingChange(boolean signalOnSchedulingChange)`
`void`	`shutdown()`	Halts the `QuartzScheduler`'s firing of `Triggers`, and cleans up all resources associated with the QuartzScheduler.
`void`	`shutdown(boolean waitForJobsToComplete)`	Halts the `QuartzScheduler`'s firing of `Triggers`, and cleans up all resources associated with the QuartzScheduler.
`void`	`standby()`	Temporarily halts the `QuartzScheduler`'s firing of `Triggers`.
`void`	`start()`	Starts the `QuartzScheduler`'s threads that fire `Triggers`.
`void`	`startDelayed(int seconds)`
`boolean`	`supportsPersistence()`
`void`	`triggerJob(JobKey jobKey, JobDataMap data)`	Trigger the identified `Job` (execute it now) - with a non-volatile trigger.
`void`	`triggerJob(OperableTrigger trig)`	Store and schedule the identified `OperableTrigger`
`boolean`	`unscheduleJob(TriggerKey triggerKey)`	Remove the indicated `Trigger` from the scheduler.
`boolean`	`unscheduleJobs(java.util.List<TriggerKey> triggerKeys)`
`void`	`validateState()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - QuartzScheduler
```
public QuartzScheduler(QuartzSchedulerResources resources,
                       long idleWaitTime,
                       @Deprecated
                       long dbRetryInterval)
                throws SchedulerException
```
    Create a QuartzScheduler with the given configuration properties.
    
    Throws:
    
    SchedulerException
    
    See Also:
    
    QuartzSchedulerResources
- Method Detail
  - initialize
```
public void initialize()
                throws SchedulerException
```
    Throws:
    
    SchedulerException
  - getVersion
```
public java.lang.String getVersion()
```
    Specified by:
    
    getVersion in interface RemotableQuartzScheduler
  - getVersionMajor
```
public static java.lang.String getVersionMajor()
```
  - getVersionMinor
```
public static java.lang.String getVersionMinor()
```
  - getVersionIteration
```
public static java.lang.String getVersionIteration()
```
  - getSchedulerSignaler
```
public SchedulerSignaler getSchedulerSignaler()
```
  - getLog
```
public org.slf4j.Logger getLog()
```
  - getSchedulerName
```
public java.lang.String getSchedulerName()
```
    Returns the name of the QuartzScheduler.
    
    Specified by:
    
    getSchedulerName in interface RemotableQuartzScheduler
  - getSchedulerInstanceId
```
public java.lang.String getSchedulerInstanceId()
```
    Returns the instance Id of the QuartzScheduler.
    
    Specified by:
    
    getSchedulerInstanceId in interface RemotableQuartzScheduler
  - getSchedulerThreadGroup
```
public java.lang.ThreadGroup getSchedulerThreadGroup()
```
    Returns the name of the thread group for Quartz's main threads.
  - addNoGCObject
```
public void addNoGCObject(java.lang.Object obj)
```
  - removeNoGCObject
```
public boolean removeNoGCObject(java.lang.Object obj)
```
  - getSchedulerContext
```
public SchedulerContext getSchedulerContext()
                                     throws SchedulerException
```
    Returns the SchedulerContext of the Scheduler.
    
    Specified by:
    
    getSchedulerContext in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - isSignalOnSchedulingChange
```
public boolean isSignalOnSchedulingChange()
```
  - setSignalOnSchedulingChange
```
public void setSignalOnSchedulingChange(boolean signalOnSchedulingChange)
```
  - start
```
public void start()
           throws SchedulerException
```
    Starts the QuartzScheduler's threads that fire Triggers.
    
    All Triggers that have misfired will be passed to the appropriate TriggerListener(s).
    
    Specified by:
    
    start in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - startDelayed
```
public void startDelayed(int seconds)
                  throws SchedulerException
```
    Specified by:
    
    startDelayed in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - standby
```
public void standby()
```
    Temporarily halts the QuartzScheduler's firing of Triggers.
    
    The scheduler is not destroyed, and can be re-started at any time.
    
    Specified by:
    
    standby in interface RemotableQuartzScheduler
  - isInStandbyMode
```
public boolean isInStandbyMode()
```
    Reports whether the Scheduler is paused.
    
    Specified by:
    
    isInStandbyMode in interface RemotableQuartzScheduler
  - runningSince
```
public java.util.Date runningSince()
```
    Specified by:
    
    runningSince in interface RemotableQuartzScheduler
  - numJobsExecuted
```
public int numJobsExecuted()
```
    Specified by:
    
    numJobsExecuted in interface RemotableQuartzScheduler
  - getJobStoreClass
```
public java.lang.Class<?> getJobStoreClass()
```
    Specified by:
    
    getJobStoreClass in interface RemotableQuartzScheduler
  - supportsPersistence
```
public boolean supportsPersistence()
```
    Specified by:
    
    supportsPersistence in interface RemotableQuartzScheduler
  - isClustered
```
public boolean isClustered()
```
    Specified by:
    
    isClustered in interface RemotableQuartzScheduler
  - getThreadPoolClass
```
public java.lang.Class<?> getThreadPoolClass()
```
    Specified by:
    
    getThreadPoolClass in interface RemotableQuartzScheduler
  - getThreadPoolSize
```
public int getThreadPoolSize()
```
    Specified by:
    
    getThreadPoolSize in interface RemotableQuartzScheduler
  - shutdown
```
public void shutdown()
```
    Halts the QuartzScheduler's firing of Triggers, and cleans up all resources associated with the QuartzScheduler. Equivalent to shutdown(false).
    
    The scheduler cannot be re-started.
    
    Specified by:
    
    shutdown in interface RemotableQuartzScheduler
  - shutdown
```
public void shutdown(boolean waitForJobsToComplete)
```
    Halts the QuartzScheduler's firing of Triggers, and cleans up all resources associated with the QuartzScheduler.
    
    The scheduler cannot be re-started.
    
    Specified by:
    
    shutdown in interface RemotableQuartzScheduler
    
    Parameters:
    
    waitForJobsToComplete - if true the scheduler will not allow this method to return until all currently executing jobs have completed.
  - isShutdown
```
public boolean isShutdown()
```
    Reports whether the Scheduler has been shutdown.
    
    Specified by:
    
    isShutdown in interface RemotableQuartzScheduler
  - isShuttingDown
```
public boolean isShuttingDown()
```
  - isStarted
```
public boolean isStarted()
```
  - validateState
```
public void validateState()
                   throws SchedulerException
```
    Throws:
    
    SchedulerException
  - getCurrentlyExecutingJobs
```
public java.util.List<JobExecutionContext> getCurrentlyExecutingJobs()
```
    Return a list of JobExecutionContext objects that represent all currently executing Jobs in this Scheduler instance.
    
    This method is not cluster aware. That is, it will only return Jobs currently executing in this Scheduler instance, not across the entire cluster.
    
    Note that the list returned is an 'instantaneous' snap-shot, and that as soon as it's returned, the true list of executing jobs may be different.
    
    Specified by:
    
    getCurrentlyExecutingJobs in interface RemotableQuartzScheduler
  - scheduleJob
```
public java.util.Date scheduleJob(JobDetail jobDetail,
                                  Trigger trigger)
                           throws SchedulerException
```
    Add the Job identified by the given JobDetail to the Scheduler, and associate the given Trigger with it.
    
    If the given Trigger does not reference any Job, then it will be set to reference the Job passed with it into this method.
    
    Specified by:
    
    scheduleJob in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException - if the Job or Trigger cannot be added to the Scheduler, or there is an internal Scheduler error.
  - scheduleJob
```
public java.util.Date scheduleJob(Trigger trigger)
                           throws SchedulerException
```
    Schedule the given Trigger with the Job identified by the Trigger's settings.
    
    Specified by:
    
    scheduleJob in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException - if the indicated Job does not exist, or the Trigger cannot be added to the Scheduler, or there is an internal Scheduler error.
  - addJob
```
public void addJob(JobDetail jobDetail,
                   boolean replace)
            throws SchedulerException
```
    Add the given Job to the Scheduler - with no associated Trigger. The Job will be 'dormant' until it is scheduled with a Trigger, or Scheduler.triggerJob() is called for it.
    
    The Job must by definition be 'durable', if it is not, SchedulerException will be thrown.
    
    Specified by:
    
    addJob in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException - if there is an internal Scheduler error, or if the Job is not durable, or a Job with the same name already exists, and replace is false.
  - addJob
```
public void addJob(JobDetail jobDetail,
                   boolean replace,
                   boolean storeNonDurableWhileAwaitingScheduling)
            throws SchedulerException
```
    Specified by:
    
    addJob in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - deleteJob
```
public boolean deleteJob(JobKey jobKey)
                  throws SchedulerException
```
    Delete the identified Job from the Scheduler - and any associated Triggers.
    
    Specified by:
    
    deleteJob in interface RemotableQuartzScheduler
    
    Returns:
    
    true if the Job was found and deleted.
    
    Throws:
    
    SchedulerException - if there is an internal Scheduler error.
  - deleteJobs
```
public boolean deleteJobs(java.util.List<JobKey> jobKeys)
                   throws SchedulerException
```
    Specified by:
    
    deleteJobs in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - scheduleJobs
```
public void scheduleJobs(java.util.Map<JobDetail,java.util.Set<? extends Trigger>> triggersAndJobs,
                         boolean replace)
                  throws SchedulerException
```
    Specified by:
    
    scheduleJobs in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - scheduleJob
```
public void scheduleJob(JobDetail jobDetail,
                        java.util.Set<? extends Trigger> triggersForJob,
                        boolean replace)
                 throws SchedulerException
```
    Specified by:
    
    scheduleJob in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - unscheduleJobs
```
public boolean unscheduleJobs(java.util.List<TriggerKey> triggerKeys)
                       throws SchedulerException
```
    Specified by:
    
    unscheduleJobs in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - unscheduleJob
```
public boolean unscheduleJob(TriggerKey triggerKey)
                      throws SchedulerException
```
    Remove the indicated Trigger from the scheduler.
    
    Specified by:
    
    unscheduleJob in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - rescheduleJob
```
public java.util.Date rescheduleJob(TriggerKey triggerKey,
                                    Trigger newTrigger)
                             throws SchedulerException
```
    Remove (delete) the Trigger with the given name, and store the new given one - which must be associated with the same job.
    
    Specified by:
    
    rescheduleJob in interface RemotableQuartzScheduler
    
    Parameters:
    
    newTrigger - The new Trigger to be stored.
    
    Returns:
    
    null if a Trigger with the given name and group was not found and removed from the store, otherwise the first fire time of the newly scheduled trigger.
    
    Throws:
    
    SchedulerException
  - triggerJob
```
public void triggerJob(JobKey jobKey,
                       JobDataMap data)
                throws SchedulerException
```
    Trigger the identified Job (execute it now) - with a non-volatile trigger.
    
    Specified by:
    
    triggerJob in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - triggerJob
```
public void triggerJob(OperableTrigger trig)
                throws SchedulerException
```
    Store and schedule the identified OperableTrigger
    
    Specified by:
    
    triggerJob in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - pauseTrigger
```
public void pauseTrigger(TriggerKey triggerKey)
                  throws SchedulerException
```
    Pause the Trigger with the given name.
    
    Specified by:
    
    pauseTrigger in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - pauseTriggers
```
public void pauseTriggers(GroupMatcher<TriggerKey> matcher)
                   throws SchedulerException
```
    Pause all of the Triggers in the matching groups.
    
    Specified by:
    
    pauseTriggers in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - pauseJob
```
public void pauseJob(JobKey jobKey)
              throws SchedulerException
```
    Pause the JobDetail with the given name - by pausing all of its current Triggers.
    
    Specified by:
    
    pauseJob in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - pauseJobs
```
public void pauseJobs(GroupMatcher<JobKey> groupMatcher)
               throws SchedulerException
```
    Pause all of the JobDetails in the matching groups - by pausing all of their Triggers.
    
    Specified by:
    
    pauseJobs in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - resumeTrigger
```
public void resumeTrigger(TriggerKey triggerKey)
                   throws SchedulerException
```
    Resume (un-pause) the Trigger with the given name.
    
    If the Trigger missed one or more fire-times, then the Trigger's misfire instruction will be applied.
    
    Specified by:
    
    resumeTrigger in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - resumeTriggers
```
public void resumeTriggers(GroupMatcher<TriggerKey> matcher)
                    throws SchedulerException
```
    Resume (un-pause) all of the Triggers in the matching groups.
    
    If any Trigger missed one or more fire-times, then the Trigger's misfire instruction will be applied.
    
    Specified by:
    
    resumeTriggers in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - getPausedTriggerGroups
```
public java.util.Set<java.lang.String> getPausedTriggerGroups()
                                                       throws SchedulerException
```
    Specified by:
    
    getPausedTriggerGroups in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - resumeJob
```
public void resumeJob(JobKey jobKey)
               throws SchedulerException
```
    Resume (un-pause) the JobDetail with the given name.
    
    If any of the Job'sTrigger s missed one or more fire-times, then the Trigger's misfire instruction will be applied.
    
    Specified by:
    
    resumeJob in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - resumeJobs
```
public void resumeJobs(GroupMatcher<JobKey> matcher)
                throws SchedulerException
```
    Resume (un-pause) all of the JobDetails in the matching groups.
    
    If any of the Job s had Trigger s that missed one or more fire-times, then the Trigger's misfire instruction will be applied.
    
    Specified by:
    
    resumeJobs in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - pauseAll
```
public void pauseAll()
              throws SchedulerException
```
    Pause all triggers - equivalent of calling pauseTriggers(GroupMatcher) with a matcher matching all known groups.
    
    When resumeAll() is called (to un-pause), trigger misfire instructions WILL be applied.
    
    Specified by:
    
    pauseAll in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
    
    See Also:
    
    resumeAll(), pauseTriggers(org.quartz.impl.matchers.GroupMatcher), standby()
  - resumeAll
```
public void resumeAll()
               throws SchedulerException
```
    Resume (un-pause) all triggers - equivalent of calling resumeTriggerGroup(group) on every group.
    
    If any Trigger missed one or more fire-times, then the Trigger's misfire instruction will be applied.
    
    Specified by:
    
    resumeAll in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
    
    See Also:
    
    pauseAll()
  - getJobGroupNames
```
public java.util.List<java.lang.String> getJobGroupNames()
                                                  throws SchedulerException
```
    Get the names of all known Job groups.
    
    Specified by:
    
    getJobGroupNames in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - getJobKeys
```
public java.util.Set<JobKey> getJobKeys(GroupMatcher<JobKey> matcher)
                                 throws SchedulerException
```
    Get the names of all the Jobs in the matching groups.
    
    Specified by:
    
    getJobKeys in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - getTriggersOfJob
```
public java.util.List<? extends Trigger> getTriggersOfJob(JobKey jobKey)
                                                   throws SchedulerException
```
    Get all Trigger s that are associated with the identified JobDetail.
    
    Specified by:
    
    getTriggersOfJob in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - getTriggerGroupNames
```
public java.util.List<java.lang.String> getTriggerGroupNames()
                                                      throws SchedulerException
```
    Get the names of all known Trigger groups.
    
    Specified by:
    
    getTriggerGroupNames in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - getTriggerKeys
```
public java.util.Set<TriggerKey> getTriggerKeys(GroupMatcher<TriggerKey> matcher)
                                         throws SchedulerException
```
    Get the names of all the Triggers in the matching groups.
    
    Specified by:
    
    getTriggerKeys in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - getJobDetail
```
public JobDetail getJobDetail(JobKey jobKey)
                       throws SchedulerException
```
    Get the JobDetail for the Job instance with the given name and group.
    
    Specified by:
    
    getJobDetail in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - getTrigger
```
public Trigger getTrigger(TriggerKey triggerKey)
                   throws SchedulerException
```
    Get the Trigger instance with the given name and group.
    
    Specified by:
    
    getTrigger in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - checkExists
```
public boolean checkExists(JobKey jobKey)
                    throws SchedulerException
```
    Determine whether a Job with the given identifier already exists within the scheduler.
    
    Specified by:
    
    checkExists in interface RemotableQuartzScheduler
    
    Parameters:
    
    jobKey - the identifier to check for
    
    Returns:
    
    true if a Job exists with the given identifier
    
    Throws:
    
    SchedulerException
  - checkExists
```
public boolean checkExists(TriggerKey triggerKey)
                    throws SchedulerException
```
    Determine whether a Trigger with the given identifier already exists within the scheduler.
    
    Specified by:
    
    checkExists in interface RemotableQuartzScheduler
    
    Parameters:
    
    triggerKey - the identifier to check for
    
    Returns:
    
    true if a Trigger exists with the given identifier
    
    Throws:
    
    SchedulerException
  - clear
```
public void clear()
           throws SchedulerException
```
    Clears (deletes!) all scheduling data - all Jobs, Triggers Calendars.
    
    Specified by:
    
    clear in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - getTriggerState
```
public Trigger.TriggerState getTriggerState(TriggerKey triggerKey)
                                     throws SchedulerException
```
    Get the current state of the identified Trigger.
    J *
    
    Specified by:
    
    getTriggerState in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
    
    See Also:
    
    Trigger.TriggerState
  - resetTriggerFromErrorState
```
public void resetTriggerFromErrorState(TriggerKey triggerKey)
                                throws SchedulerException
```
    Specified by:
    
    resetTriggerFromErrorState in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - addCalendar
```
public void addCalendar(java.lang.String calName,
                        Calendar calendar,
                        boolean replace,
                        boolean updateTriggers)
                 throws SchedulerException
```
    Add (register) the given Calendar to the Scheduler.
    
    Specified by:
    
    addCalendar in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException - if there is an internal Scheduler error, or a Calendar with the same name already exists, and replace is false.
  - deleteCalendar
```
public boolean deleteCalendar(java.lang.String calName)
                       throws SchedulerException
```
    Delete the identified Calendar from the Scheduler.
    
    Specified by:
    
    deleteCalendar in interface RemotableQuartzScheduler
    
    Returns:
    
    true if the Calendar was found and deleted.
    
    Throws:
    
    SchedulerException - if there is an internal Scheduler error.
  - getCalendar
```
public Calendar getCalendar(java.lang.String calName)
                     throws SchedulerException
```
    Get the Calendar instance with the given name.
    
    Specified by:
    
    getCalendar in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - getCalendarNames
```
public java.util.List<java.lang.String> getCalendarNames()
                                                  throws SchedulerException
```
    Get the names of all registered Calendars.
    
    Specified by:
    
    getCalendarNames in interface RemotableQuartzScheduler
    
    Throws:
    
    SchedulerException
  - getListenerManager
```
public ListenerManager getListenerManager()
```
  - addInternalJobListener
```
public void addInternalJobListener(JobListener jobListener)
```
    Add the given JobListener to the Scheduler's internal list.
  - removeInternalJobListener
```
public boolean removeInternalJobListener(java.lang.String name)
```
    Remove the identified JobListener from the Scheduler's list of internal listeners.
    
    Returns:
    
    true if the identified listener was found in the list, and removed.
  - getInternalJobListeners
```
public java.util.List<JobListener> getInternalJobListeners()
```
    Get a List containing all of the JobListeners in the Scheduler's internal list.
  - getInternalJobListener
```
public JobListener getInternalJobListener(java.lang.String name)
```
    Get the internal JobListener that has the given name.
  - addInternalTriggerListener
```
public void addInternalTriggerListener(TriggerListener triggerListener)
```
    Add the given TriggerListener to the Scheduler's internal list.
  - removeinternalTriggerListener
```
public boolean removeinternalTriggerListener(java.lang.String name)
```
    Remove the identified TriggerListener from the Scheduler's list of internal listeners.
    
    Returns:
    
    true if the identified listener was found in the list, and removed.
  - getInternalTriggerListeners
```
public java.util.List<TriggerListener> getInternalTriggerListeners()
```
    Get a list containing all of the TriggerListeners in the Scheduler's internal list.
  - getInternalTriggerListener
```
public TriggerListener getInternalTriggerListener(java.lang.String name)
```
    Get the internal TriggerListener that has the given name.
  - addInternalSchedulerListener
```
public void addInternalSchedulerListener(SchedulerListener schedulerListener)
```
    Register the given SchedulerListener with the Scheduler's list of internal listeners.
  - removeInternalSchedulerListener
```
public boolean removeInternalSchedulerListener(SchedulerListener schedulerListener)
```
    Remove the given SchedulerListener from the Scheduler's list of internal listeners.
    
    Returns:
    
    true if the identified listener was found in the list, and removed.
  - getInternalSchedulerListeners
```
public java.util.List<SchedulerListener> getInternalSchedulerListeners()
```
    Get a List containing all of the internal SchedulerListeners registered with the Scheduler.
  - notifyJobStoreJobComplete
```
protected void notifyJobStoreJobComplete(OperableTrigger trigger,
                                         JobDetail detail,
                                         Trigger.CompletedExecutionInstruction instCode)
```
  - notifyJobStoreJobVetoed
```
protected void notifyJobStoreJobVetoed(OperableTrigger trigger,
                                       JobDetail detail,
                                       Trigger.CompletedExecutionInstruction instCode)
```
  - notifySchedulerThread
```
protected void notifySchedulerThread(long candidateNewNextFireTime)
```
  - notifyTriggerListenersFired
```
public boolean notifyTriggerListenersFired(JobExecutionContext jec)
                                    throws SchedulerException
```
    Throws:
    
    SchedulerException
  - notifyTriggerListenersMisfired
```
public void notifyTriggerListenersMisfired(Trigger trigger)
                                    throws SchedulerException
```
    Throws:
    
    SchedulerException
  - notifyTriggerListenersComplete
```
public void notifyTriggerListenersComplete(JobExecutionContext jec,
                                           Trigger.CompletedExecutionInstruction instCode)
                                    throws SchedulerException
```
    Throws:
    
    SchedulerException
  - notifyJobListenersToBeExecuted
```
public void notifyJobListenersToBeExecuted(JobExecutionContext jec)
                                    throws SchedulerException
```
    Throws:
    
    SchedulerException
  - notifyJobListenersWasVetoed
```
public void notifyJobListenersWasVetoed(JobExecutionContext jec)
                                 throws SchedulerException
```
    Throws:
    
    SchedulerException
  - notifyJobListenersWasExecuted
```
public void notifyJobListenersWasExecuted(JobExecutionContext jec,
                                          JobExecutionException je)
                                   throws SchedulerException
```
    Throws:
    
    SchedulerException
  - notifySchedulerListenersError
```
public void notifySchedulerListenersError(java.lang.String msg,
                                          SchedulerException se)
```
  - notifySchedulerListenersSchduled
```
public void notifySchedulerListenersSchduled(Trigger trigger)
```
  - notifySchedulerListenersUnscheduled
```
public void notifySchedulerListenersUnscheduled(TriggerKey triggerKey)
```
  - notifySchedulerListenersFinalized
```
public void notifySchedulerListenersFinalized(Trigger trigger)
```
  - notifySchedulerListenersPausedTrigger
```
public void notifySchedulerListenersPausedTrigger(TriggerKey triggerKey)
```
  - notifySchedulerListenersPausedTriggers
```
public void notifySchedulerListenersPausedTriggers(java.lang.String group)
```
  - notifySchedulerListenersResumedTrigger
```
public void notifySchedulerListenersResumedTrigger(TriggerKey key)
```
  - notifySchedulerListenersResumedTriggers
```
public void notifySchedulerListenersResumedTriggers(java.lang.String group)
```
  - notifySchedulerListenersPausedJob
```
public void notifySchedulerListenersPausedJob(JobKey key)
```
  - notifySchedulerListenersPausedJobs
```
public void notifySchedulerListenersPausedJobs(java.lang.String group)
```
  - notifySchedulerListenersResumedJob
```
public void notifySchedulerListenersResumedJob(JobKey key)
```
  - notifySchedulerListenersResumedJobs
```
public void notifySchedulerListenersResumedJobs(java.lang.String group)
```
  - notifySchedulerListenersInStandbyMode
```
public void notifySchedulerListenersInStandbyMode()
```
  - notifySchedulerListenersStarted
```
public void notifySchedulerListenersStarted()
```
  - notifySchedulerListenersStarting
```
public void notifySchedulerListenersStarting()
```
  - notifySchedulerListenersShutdown
```
public void notifySchedulerListenersShutdown()
```
  - notifySchedulerListenersShuttingdown
```
public void notifySchedulerListenersShuttingdown()
```
  - notifySchedulerListenersJobAdded
```
public void notifySchedulerListenersJobAdded(JobDetail jobDetail)
```
  - notifySchedulerListenersJobDeleted
```
public void notifySchedulerListenersJobDeleted(JobKey jobKey)
```
  - setJobFactory
```
public void setJobFactory(JobFactory factory)
                   throws SchedulerException
```
    Throws:
    
    SchedulerException
  - getJobFactory
```
public JobFactory getJobFactory()
```
  - interrupt
```
public boolean interrupt(JobKey jobKey)
                  throws UnableToInterruptJobException
```
    Interrupt all instances of the identified InterruptableJob executing in this Scheduler instance.
    This method is not cluster aware. That is, it will only interrupt instances of the identified InterruptableJob currently executing in this Scheduler instance, not across the entire cluster.
    
    Specified by:
    
    interrupt in interface RemotableQuartzScheduler
    
    Throws:
    
    UnableToInterruptJobException
    
    See Also:
    
    RemotableQuartzScheduler.interrupt(JobKey)
  - interrupt
```
public boolean interrupt(java.lang.String fireInstanceId)
                  throws UnableToInterruptJobException
```
    Interrupt the identified InterruptableJob executing in this Scheduler instance.
    This method is not cluster aware. That is, it will only interrupt instances of the identified InterruptableJob currently executing in this Scheduler instance, not across the entire cluster.
    
    Specified by:
    
    interrupt in interface RemotableQuartzScheduler
    
    Throws:
    
    UnableToInterruptJobException
    
    See Also:
    
    RemotableQuartzScheduler.interrupt(JobKey)

Class QuartzScheduler

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

QuartzScheduler

Method Detail

initialize

getVersion

getVersionMajor

getVersionMinor

getVersionIteration

getSchedulerSignaler

getLog

getSchedulerName

getSchedulerInstanceId

getSchedulerThreadGroup

addNoGCObject

removeNoGCObject

getSchedulerContext

isSignalOnSchedulingChange

setSignalOnSchedulingChange

start

startDelayed

standby

isInStandbyMode

runningSince

numJobsExecuted

getJobStoreClass

supportsPersistence

isClustered

getThreadPoolClass

getThreadPoolSize

shutdown

shutdown

isShutdown

isShuttingDown

isStarted

validateState

getCurrentlyExecutingJobs

scheduleJob

scheduleJob

addJob

addJob

deleteJob

deleteJobs

scheduleJobs

scheduleJob

unscheduleJobs

unscheduleJob

rescheduleJob

triggerJob

triggerJob

pauseTrigger

pauseTriggers

pauseJob

pauseJobs

resumeTrigger

resumeTriggers

getPausedTriggerGroups

resumeJob

resumeJobs

pauseAll

resumeAll

getJobGroupNames

getJobKeys

getTriggersOfJob

getTriggerGroupNames

getTriggerKeys

getJobDetail

getTrigger

checkExists

checkExists

clear

getTriggerState

resetTriggerFromErrorState

addCalendar

deleteCalendar

getCalendar

getCalendarNames