Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.quartz
Interface Scheduler

All Known Implementing Classes:
  JBoss4RMIRemoteMBeanScheduler, RemoteMBeanScheduler, RemoteScheduler, StdScheduler

    public interface Scheduler

This is the main interface of a Quartz Scheduler.

A `Scheduler` maintains a registry of ``JobDetail``s and ``Trigger``s. Once registered, the `Scheduler` is responsible for executing `Job` s when their associated `Trigger` s fire (when their scheduled time arrives).

`Scheduler` instances are produced by a ``SchedulerFactory``. A scheduler that has already been created/initialized can be found and used through the same factory that produced it. After a `Scheduler` has been created, it is in "stand-by" mode, and must have its `start()` method called before it will fire any `Job`s.

`Job` s are to be created by the 'client program', by defining a class that implements the ``Job`` interface. ``JobDetail`` objects are then created (also by the client) to define a individual instances of the `Job`. `JobDetail` instances can then be registered with the `Scheduler` via the `scheduleJob(JobDetail, Trigger)` or `addJob(JobDetail, boolean)` method.

`Trigger` s can then be defined to fire individual `Job` instances based on given schedules. `SimpleTrigger` s are most useful for one-time firings, or firing at an exact moment in time, with N repeats with a given delay between them. `CronTrigger` s allow scheduling based on time of day, day of week, day of month, and month of year.

`Job` s and `Trigger` s have a name and group associated with them, which should uniquely identify them within a single ``Scheduler``. The 'group' feature may be useful for creating logical groupings or categorizations of `Jobs` s and `Triggers`s. If you don't have need for assigning a group to a given `Jobs` of `Triggers`, then you can use the `DEFAULT_GROUP` constant defined on this interface.

Stored `Job` s can also be 'manually' triggered through the use of the `triggerJob(String jobName, String jobGroup)` function.

Client programs may also be interested in the 'listener' interfaces that are available from Quartz. The ``JobListener`` interface provides notifications of `Job` executions. The ``TriggerListener`` interface provides notifications of `Trigger` firings. The ``SchedulerListener`` interface provides notifications of `Scheduler` events and errors. Listeners can be associated with local schedulers through the `ListenerManager` interface.

The setup/configuration of a `Scheduler` instance is very customizable. Please consult the documentation distributed with Quartz.

Author:
  James House, Sharada Jambula
See Also:
  `Job`, `JobDetail`, `JobBuilder`, `Trigger`, `TriggerBuilder`, `JobListener`, `TriggerListener`, `SchedulerListener`

Field Summary
`static String` | `DEFAULT_FAIL_OVER_GROUP` A constant `Trigger` group name used internally by the scheduler - clients should not use the value of this constant ("FAILED_OVER_JOBS") for the name of a `Trigger`'s group.
`static String` | `DEFAULT_GROUP` A (possibly) useful constant that can be used for specifying the group that `Job` and `Trigger` instances belong to.
`static String` | `DEFAULT_RECOVERY_GROUP` A constant `Trigger` group name used internally by the scheduler - clients should not use the value of this constant ("RECOVERING_JOBS") for the name of a `Trigger`'s group.
`static String` | `FAILED_JOB_ORIGINAL_TRIGGER_FIRETIME_IN_MILLISECONDS` A constant `JobDataMap` key that can be used to retrieve the fire time of the original `Trigger` from a recovery trigger's data map in the case of a job recovering after a failed scheduler instance.
`static String` | `FAILED_JOB_ORIGINAL_TRIGGER_GROUP` A constant `JobDataMap` key that can be used to retrieve the group of the original `Trigger` from a recovery trigger's data map in the case of a job recovering after a failed scheduler instance.
`static String` | `FAILED_JOB_ORIGINAL_TRIGGER_NAME` A constant `JobDataMap` key that can be used to retrieve the name of the original `Trigger` from a recovery trigger's data map in the case of a job recovering after a failed scheduler instance.
`static String` | `FAILED_JOB_ORIGINAL_TRIGGER_SCHEDULED_FIRETIME_IN_MILLISECONDS` A constant `JobDataMap` key that can be used to retrieve the scheduled fire time of the original `Trigger` from a recovery trigger's data map in the case of a job recovering after a failed scheduler instance.

Method Summary
`void` | `addCalendar(String calName, Calendar calendar, boolean replace, boolean updateTriggers)` Add (register) the given `Calendar` to the Scheduler.
`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)` Add the given `Job` to the Scheduler - with no associated `Trigger`.
`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(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(List<JobKey> jobKeys)` Delete the identified `Job`s from the Scheduler - and any associated `Trigger`s.
`Calendar` | `getCalendar(String calName)` Get the ``Calendar`` instance with the given name.
`List<String>` | `getCalendarNames()` Get the names of all registered ``Calendar`s`.
`SchedulerContext` | `getContext()` Returns the `SchedulerContext` of the `Scheduler`.
`List<JobExecutionContext>` | `getCurrentlyExecutingJobs()` Return a list of `JobExecutionContext` objects that represent all currently executing Jobs in this Scheduler instance.
`JobDetail` | `getJobDetail(JobKey jobKey)` Get the ``JobDetail`` for the `Job` instance with the given key.
`List<String>` | `getJobGroupNames()` Get the names of all known ``JobDetail`` groups.
`Set<JobKey>` | `getJobKeys(GroupMatcher<JobKey> matcher)` Get the keys of all the ``JobDetail`s` in the matching groups.
`ListenerManager` | `getListenerManager()` Get a reference to the scheduler's `ListenerManager`, through which listeners may be registered.
`SchedulerMetaData` | `getMetaData()` Get a `SchedulerMetaData` object describing the settings and capabilities of the scheduler instance.
`Set<String>` | `getPausedTriggerGroups()` Get the names of all ``Trigger`` groups that are paused.
`String` | `getSchedulerInstanceId()` Returns the instance Id of the `Scheduler`.
`String` | `getSchedulerName()` Returns the name of the `Scheduler`.
`Trigger` | `getTrigger(TriggerKey triggerKey)` Get the ``Trigger`` instance with the given key.
`List<String>` | `getTriggerGroupNames()` Get the names of all known ``Trigger`` groups.
`Set<TriggerKey>` | `getTriggerKeys(GroupMatcher<TriggerKey> matcher)` Get the names of all the ``Trigger`s` in the given group.
`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``.
`boolean` | `interrupt(JobKey jobKey)` Request the interruption, within this Scheduler instance, of all currently executing instances of the identified `Job`, which must be an implementor of the `InterruptableJob` interface.
`boolean` | `interrupt(String fireInstanceId)` Request the interruption, within this Scheduler instance, of the identified executing `Job` instance, which must be an implementor of the `InterruptableJob` interface.
`boolean` | `isInStandbyMode()` Reports whether the `Scheduler` is in stand-by mode.
`boolean` | `isShutdown()` Reports whether the `Scheduler` has been shutdown.
`boolean` | `isStarted()` Whether the scheduler has been started.
`void` | `pauseAll()` Pause all triggers - similar to calling `pauseTriggerGroup(group)` on every group, however, after using this method `resumeAll()` must be called to clear the scheduler's state of 'remembering' that all new triggers will be paused as they are added.
`void` | `pauseJob(JobKey jobKey)` Pause the ``JobDetail`` with the given key - by pausing all of its current `Trigger`s.
`void` | `pauseJobs(GroupMatcher<JobKey> matcher)` Pause all of the ``JobDetail`s` in the matching groups - by pausing all of their `Trigger`s.
`void` | `pauseTrigger(TriggerKey triggerKey)` Pause the ``Trigger`` with the given key.
`void` | `pauseTriggers(GroupMatcher<TriggerKey> matcher)` Pause all of the ``Trigger`s` in the groups matching.
`Date` | `rescheduleJob(TriggerKey triggerKey, Trigger newTrigger)` Remove (delete) the ``Trigger`` with the given key, and store the new given one - which must be associated with the same job (the new trigger must have the job name & group specified) - however, the new trigger need not have the same name as the old trigger.
`void` | `resumeAll()` Resume (un-pause) all triggers - similar to calling `resumeTriggerGroup(group)` on every group.
`void` | `resumeJob(JobKey jobKey)` Resume (un-pause) the ``JobDetail`` with the given key.
`void` | `resumeJobs(GroupMatcher<JobKey> matcher)` Resume (un-pause) all of the ``JobDetail`s` in matching groups.
`void` | `resumeTrigger(TriggerKey triggerKey)` Resume (un-pause) the ``Trigger`` with the given key.
`void` | `resumeTriggers(GroupMatcher<TriggerKey> matcher)` Resume (un-pause) all of the ``Trigger`s` in matching groups.
`void` | `scheduleJob(JobDetail jobDetail, Set<? extends Trigger> triggersForJob, boolean replace)` Schedule the given job with the related set of triggers.
`Date` | `scheduleJob(JobDetail jobDetail, Trigger trigger)` Add the given ``JobDetail`` to the Scheduler, and associate the given ``Trigger`` with it.
`Date` | `scheduleJob(Trigger trigger)` Schedule the given ``Trigger`` with the `Job` identified by the `Trigger`'s settings.
`void` | `scheduleJobs(Map<JobDetail,Set<? extends Trigger>> triggersAndJobs, boolean replace)` Schedule all of the given jobs with the related set of triggers.
`void` | `setJobFactory(JobFactory factory)` Set the `JobFactory` that will be responsible for producing instances of `Job` classes.
`void` | `shutdown()` Halts the `Scheduler`'s firing of ``Trigger`s`, and cleans up all resources associated with the Scheduler.
`void` | `shutdown(boolean waitForJobsToComplete)` Halts the `Scheduler`'s firing of ``Trigger`s`, and cleans up all resources associated with the Scheduler.
`void` | `standby()` Temporarily halts the `Scheduler`'s firing of ``Trigger`s`.
`void` | `start()` Starts the `Scheduler`'s threads that fire ``Trigger`s`.
`void` | `startDelayed(int seconds)` Calls {#start()} after the indicated number of seconds.
`void` | `triggerJob(JobKey jobKey)` Trigger the identified ``JobDetail`` (execute it now).
`void` | `triggerJob(JobKey jobKey, JobDataMap data)` Trigger the identified ``JobDetail`` (execute it now).
`boolean` | `unscheduleJob(TriggerKey triggerKey)` Remove the indicated ``Trigger`` from the scheduler.
`boolean` | `unscheduleJobs(List<TriggerKey> triggerKeys)` Remove all of the indicated ``Trigger``s from the scheduler.

Field Detail

### DEFAULT_GROUP

    static final String DEFAULT_GROUP

  A (possibly) useful constant that can be used for specifying the group that `Job` and `Trigger` instances belong to.

  See Also:
    Constant Field Values

### DEFAULT_RECOVERY_GROUP

    static final String DEFAULT_RECOVERY_GROUP

  A constant `Trigger` group name used internally by the scheduler - clients should not use the value of this constant ("RECOVERING_JOBS") for the name of a `Trigger`'s group.

  See Also:
    `JobDetail.requestsRecovery()`, Constant Field Values

### DEFAULT_FAIL_OVER_GROUP

    static final String DEFAULT_FAIL_OVER_GROUP

  A constant `Trigger` group name used internally by the scheduler - clients should not use the value of this constant ("FAILED_OVER_JOBS") for the name of a `Trigger`'s group.

  See Also:
    `JobDetail.requestsRecovery()`, Constant Field Values

### FAILED_JOB_ORIGINAL_TRIGGER_NAME

    static final String FAILED_JOB_ORIGINAL_TRIGGER_NAME

  A constant `JobDataMap` key that can be used to retrieve the name of the original `Trigger` from a recovery trigger's data map in the case of a job recovering after a failed scheduler instance.

  See Also:
    `JobDetail.requestsRecovery()`, Constant Field Values

### FAILED_JOB_ORIGINAL_TRIGGER_GROUP

    static final String FAILED_JOB_ORIGINAL_TRIGGER_GROUP

  A constant `JobDataMap` key that can be used to retrieve the group of the original `Trigger` from a recovery trigger's data map in the case of a job recovering after a failed scheduler instance.

  See Also:
    `JobDetail.requestsRecovery()`, Constant Field Values

### FAILED_JOB_ORIGINAL_TRIGGER_FIRETIME_IN_MILLISECONDS

    static final String FAILED_JOB_ORIGINAL_TRIGGER_FIRETIME_IN_MILLISECONDS

  A constant `JobDataMap` key that can be used to retrieve the fire time of the original `Trigger` from a recovery trigger's data map in the case of a job recovering after a failed scheduler instance.

  Note that this is the time the original firing actually occurred, which may be different from the scheduled fire time - as a trigger doesn't always fire exactly on time.

  See Also:
    `JobDetail.requestsRecovery()`, Constant Field Values

### FAILED_JOB_ORIGINAL_TRIGGER_SCHEDULED_FIRETIME_IN_MILLISECONDS

    static final String FAILED_JOB_ORIGINAL_TRIGGER_SCHEDULED_FIRETIME_IN_MILLISECONDS

  A constant `JobDataMap` key that can be used to retrieve the scheduled fire time of the original `Trigger` from a recovery trigger's data map in the case of a job recovering after a failed scheduler instance.

  Note that this is the time the original firing was scheduled for, which may be different from the actual firing time - as a trigger doesn't always fire exactly on time.

  See Also:
    `JobDetail.requestsRecovery()`, Constant Field Values

Method Detail

### getSchedulerName

    String getSchedulerName()
                            throws SchedulerException

  Returns the name of the `Scheduler`.

  Throws:
    `SchedulerException`

### getSchedulerInstanceId

    String getSchedulerInstanceId()
                                  throws SchedulerException

  Returns the instance Id of the `Scheduler`.

  Throws:
    `SchedulerException`

### getContext

    SchedulerContext getContext()
                                throws SchedulerException

  Returns the `SchedulerContext` of the `Scheduler`.

  Throws:
    `SchedulerException`

### start

    void start()
               throws SchedulerException

  Starts the `Scheduler`'s threads that fire ``Trigger`s`. When a scheduler is first created it is in "stand-by" mode, and will not fire triggers. The scheduler can also be put into stand-by mode by calling the `standby()` method.

  The misfire/recovery process will be started, if it is the initial call to this method on this scheduler instance.

  Throws:
    `SchedulerException` - if `shutdown()` has been called, or there is an error within the `Scheduler`.
  See Also:
    `startDelayed(int)`, `standby()`, `shutdown()`

### startDelayed

    void startDelayed(int seconds)
                      throws SchedulerException

  Calls {#start()} after the indicated number of seconds. (This call does not block). This can be useful within applications that have initializers that create the scheduler immediately, before the resources needed by the executing jobs have been fully initialized.

  Throws:
    `SchedulerException` - if `shutdown()` has been called, or there is an error within the `Scheduler`.
  See Also:
    `start()`, `standby()`, `shutdown()`

### isStarted

    boolean isStarted()
                      throws SchedulerException

  Whether the scheduler has been started.

  Note: This only reflects whether ``start()`` has ever been called on this Scheduler, so it will return `true` even if the `Scheduler` is currently in standby mode or has been since shutdown.

  Throws:
    `SchedulerException`
  See Also:
    `start()`, `isShutdown()`, `isInStandbyMode()`

### standby

    void standby()
                 throws SchedulerException

  Temporarily halts the `Scheduler`'s firing of ``Trigger`s`.

  When `start()` is called (to bring the scheduler out of stand-by mode), trigger misfire instructions will NOT be applied during the execution of the `start()` method - any misfires will be detected immediately afterward (by the `JobStore`'s normal process).

  The scheduler is not destroyed, and can be re-started at any time.

  Throws:
    `SchedulerException`
  See Also:
    `start()`, `pauseAll()`

### isInStandbyMode

    boolean isInStandbyMode()
                            throws SchedulerException

  Reports whether the `Scheduler` is in stand-by mode.

  Throws:
    `SchedulerException`
  See Also:
    `standby()`, `start()`

### shutdown

    void shutdown()
                  throws SchedulerException

  Halts the `Scheduler`'s firing of ``Trigger`s`, and cleans up all resources associated with the Scheduler. Equivalent to `shutdown(false)`.

  The scheduler cannot be re-started.

  Throws:
    `SchedulerException`
  See Also:
    `shutdown(boolean)`

### shutdown

    void shutdown(boolean waitForJobsToComplete)
                  throws SchedulerException

  Halts the `Scheduler`'s firing of ``Trigger`s`, and cleans up all resources associated with the Scheduler.

  The scheduler cannot be re-started.

  Parameters:
    `waitForJobsToComplete` - if `true` the scheduler will not allow this method to return until all currently executing jobs have completed.
  Throws:
    `SchedulerException`
  See Also:
    `shutdown()`

### isShutdown

    boolean isShutdown()
                       throws SchedulerException

  Reports whether the `Scheduler` has been shutdown.

  Throws:
    `SchedulerException`

### getMetaData

    SchedulerMetaData getMetaData()
                                  throws SchedulerException

  Get a `SchedulerMetaData` object describing the settings and capabilities of the scheduler instance.

  Note that the data returned is an 'instantaneous' snap-shot, and that as soon as it's returned, the meta data values may be different.

  Throws:
    `SchedulerException`

### getCurrentlyExecutingJobs

    List<JobExecutionContext> getCurrentlyExecutingJobs()
                                                        throws SchedulerException

  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. Also please read the doc associated with `JobExecutionContext`- especially if you're using RMI.

  Throws:
    `SchedulerException`
  See Also:
    `JobExecutionContext`

### setJobFactory

    void setJobFactory(JobFactory factory)
                       throws SchedulerException

  Set the `JobFactory` that will be responsible for producing instances of `Job` classes.

  JobFactories may be of use to those wishing to have their application produce `Job` instances via some special mechanism, such as to give the opportunity for dependency injection.

  Throws:
    `SchedulerException`
  See Also:
    `JobFactory`

### getListenerManager

    ListenerManager getListenerManager()
                                       throws SchedulerException

  Get a reference to the scheduler's `ListenerManager`, through which listeners may be registered.

  Returns:
    the scheduler's `ListenerManager`
  Throws:
    `SchedulerException` - if the scheduler is not local
  See Also:
    `ListenerManager`, `JobListener`, `TriggerListener`, `SchedulerListener`

### scheduleJob

    Date scheduleJob(JobDetail jobDetail,
                     Trigger trigger)
                     throws SchedulerException

  Add 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.

  Throws:
    `SchedulerException` - if the Job or Trigger cannot be added to the Scheduler, or there is an internal Scheduler error.

### scheduleJob

    Date scheduleJob(Trigger trigger)
                     throws SchedulerException

  Schedule the given ``Trigger`` with the `Job` identified by the `Trigger`'s settings.

  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.

### scheduleJobs

    void scheduleJobs(Map<JobDetail,Set<? extends Trigger>> triggersAndJobs,
                      boolean replace)
                      throws SchedulerException

  Schedule all of the given jobs with the related set of triggers.

  If any of the given jobs or triggers already exist (or more specifically, if the keys are not unique) and the replace parameter is not set to true then an exception will be thrown.

  Throws:
    `ObjectAlreadyExistsException` - if the job/trigger keys are not unique and the replace flag is not set to true.
    `SchedulerException`

### scheduleJob

    void scheduleJob(JobDetail jobDetail,
                     Set<? extends Trigger> triggersForJob,
                     boolean replace)
                     throws SchedulerException

  Schedule the given job with the related set of triggers.

  If any of the given job or triggers already exist (or more specifically, if the keys are not unique) and the replace parameter is not set to true then an exception will be thrown.

  Throws:
    `ObjectAlreadyExistsException` - if the job/trigger keys are not unique and the replace flag is not set to true.
    `SchedulerException`

### unscheduleJob

    boolean unscheduleJob(TriggerKey triggerKey)
                          throws SchedulerException

  Remove the indicated ``Trigger`` from the scheduler.

  If the related job does not have any other triggers, and the job is not durable, then the job will also be deleted.

  Throws:
    `SchedulerException`

### unscheduleJobs

    boolean unscheduleJobs(List<TriggerKey> triggerKeys)
                           throws SchedulerException

  Remove all of the indicated ``Trigger``s from the scheduler.

  If the related job does not have any other triggers, and the job is not durable, then the job will also be deleted.

  Note that while this bulk operation is likely more efficient than invoking `unscheduleJob(TriggerKey triggerKey)` several times, it may have the adverse affect of holding data locks for a single long duration of time (rather than lots of small durations of time).

  Throws:
    `SchedulerException`

### rescheduleJob

    Date rescheduleJob(TriggerKey triggerKey,
                       Trigger newTrigger)
                       throws SchedulerException

  Remove (delete) the ``Trigger`` with the given key, and store the new given one - which must be associated with the same job (the new trigger must have the job name & group specified) - however, the new trigger need not have the same name as the old trigger.

  Parameters:
    `triggerKey` - identity of the trigger to replace
    `newTrigger` - The new `Trigger` to be stored.
  Returns:
    `null` if a `Trigger` with the given name & group was not found and removed from the store (and the new trigger is therefore not stored), otherwise the first fire time of the newly scheduled trigger is returned.
  Throws:
    `SchedulerException`

### addJob

    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.

  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`.
  See Also:
    `addJob(JobDetail, boolean, boolean)`

### addJob

    void addJob(JobDetail jobDetail,
                boolean replace,
                boolean storeNonDurableWhileAwaitingScheduling)
                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.

  With the `storeNonDurableWhileAwaitingScheduling` parameter set to `true`, a non-durable job can be stored. Once it is scheduled, it will resume normal non-durable behavior (i.e. be deleted once there are no remaining associated triggers).

  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`.

### deleteJob

    boolean deleteJob(JobKey jobKey)
                      throws SchedulerException

  Delete the identified `Job` from the Scheduler - and any associated `Trigger`s.

  Returns:
    true if the Job was found and deleted.
  Throws:
    `SchedulerException` - if there is an internal Scheduler error.

### deleteJobs

    boolean deleteJobs(List<JobKey> jobKeys)
                       throws SchedulerException

  Delete the identified `Job`s from the Scheduler - and any associated `Trigger`s.

  Note that while this bulk operation is likely more efficient than invoking `deleteJob(JobKey jobKey)` several times, it may have the adverse affect of holding data locks for a single long duration of time (rather than lots of small durations of time).

  Returns:
    true if all of the Jobs were found and deleted, false if one or more were not deleted.
  Throws:
    `SchedulerException` - if there is an internal Scheduler error.

### triggerJob

    void triggerJob(JobKey jobKey)
                    throws SchedulerException

  Trigger the identified ``JobDetail`` (execute it now).

  Throws:
    `SchedulerException`

### triggerJob

    void triggerJob(JobKey jobKey,
                    JobDataMap data)
                    throws SchedulerException

  Trigger the identified ``JobDetail`` (execute it now).

  Parameters:
    `data` - the (possibly `null`) JobDataMap to be associated with the trigger that fires the job immediately.
  Throws:
    `SchedulerException`

### pauseJob

    void pauseJob(JobKey jobKey)
                  throws SchedulerException

  Pause the ``JobDetail`` with the given key - by pausing all of its current `Trigger`s.

  Throws:
    `SchedulerException`
  See Also:
    `resumeJob(JobKey)`

### pauseJobs

    void pauseJobs(GroupMatcher<JobKey> matcher)
                   throws SchedulerException

  Pause all of the ``JobDetail`s` in the matching groups - by pausing all of their `Trigger`s.

  The Scheduler will "remember" the groups paused, and impose the pause on any new jobs that are added to any of those groups until it is resumed.

  NOTE: There is a limitation that only exactly matched groups can be remembered as paused. For example, if there are pre-existing job in groups "aaa" and "bbb" and a matcher is given to pause groups that start with "a" then the group "aaa" will be remembered as paused and any subsequently added jobs in group "aaa" will be paused, however if a job is added to group "axx" it will not be paused, as "axx" wasn't known at the time the "group starts with a" matcher was applied. HOWEVER, if there are pre-existing groups "aaa" and "bbb" and a matcher is given to pause the group "axx" (with a group equals matcher) then no jobs will be paused, but it will be remembered that group "axx" is paused and later when a job is added in that group, it will become paused.

  Parameters:
    `matcher` - The matcher to evaluate against know groups
  Throws:
    `SchedulerException` - On error
  See Also:
    `resumeJobs(org.quartz.impl.matchers.GroupMatcher)`

### pauseTrigger

    void pauseTrigger(TriggerKey triggerKey)
                      throws SchedulerException

  Pause the ``Trigger`` with the given key.

  Throws:
    `SchedulerException`
  See Also:
    `resumeTrigger(TriggerKey)`

### pauseTriggers

    void pauseTriggers(GroupMatcher<TriggerKey> matcher)
                       throws SchedulerException

  Pause all of the ``Trigger`s` in the groups matching.

  The Scheduler will "remember" all the groups paused, and impose the pause on any new triggers that are added to any of those groups until it is resumed.

  NOTE: There is a limitation that only exactly matched groups can be remembered as paused. For example, if there are pre-existing triggers in groups "aaa" and "bbb" and a matcher is given to pause groups that start with "a" then the group "aaa" will be remembered as paused and any subsequently added triggers in that group be paused, however if a trigger is added to group "axx" it will not be paused, as "axx" wasn't known at the time the "group starts with a" matcher was applied. HOWEVER, if there are pre-existing groups "aaa" and "bbb" and a matcher is given to pause the group "axx" (with a group equals matcher) then no triggers will be paused, but it will be remembered that group "axx" is paused and later when a trigger is added in that group, it will become paused.

  Parameters:
    `matcher` - The matcher to evaluate against know groups
  Throws:
    `SchedulerException`
  See Also:
    `resumeTriggers(org.quartz.impl.matchers.GroupMatcher)`

### resumeJob

    void resumeJob(JobKey jobKey)
                   throws SchedulerException

  Resume (un-pause) the ``JobDetail`` with the given key.

  If any of the `Job`'s`Trigger` s missed one or more fire-times, then the `Trigger`'s misfire instruction will be applied.

  Throws:
    `SchedulerException`
  See Also:
    `pauseJob(JobKey)`

### resumeJobs

    void resumeJobs(GroupMatcher<JobKey> matcher)
                    throws SchedulerException

  Resume (un-pause) all of the ``JobDetail`s` in 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.

  Parameters:
    `matcher` - The matcher to evaluate against known paused groups
  Throws:
    `SchedulerException` - On error
  See Also:
    `pauseJobs(GroupMatcher)`

### resumeTrigger

    void resumeTrigger(TriggerKey triggerKey)
                       throws SchedulerException

  Resume (un-pause) the ``Trigger`` with the given key.

  If the `Trigger` missed one or more fire-times, then the `Trigger`'s misfire instruction will be applied.

  Throws:
    `SchedulerException`
  See Also:
    `pauseTrigger(TriggerKey)`

### resumeTriggers

    void resumeTriggers(GroupMatcher<TriggerKey> matcher)
                        throws SchedulerException

  Resume (un-pause) all of the ``Trigger`s` in matching groups.

  If any `Trigger` missed one or more fire-times, then the `Trigger`'s misfire instruction will be applied.

  Parameters:
    `matcher` - The matcher to evaluate against know paused groups
  Throws:
    `SchedulerException` - On error
  See Also:
    `pauseTriggers(org.quartz.impl.matchers.GroupMatcher)`

### pauseAll

    void pauseAll()
                  throws SchedulerException

  Pause all triggers - similar to calling `pauseTriggerGroup(group)` on every group, however, after using this method `resumeAll()` must be called to clear the scheduler's state of 'remembering' that all new triggers will be paused as they are added.

  When `resumeAll()` is called (to un-pause), trigger misfire instructions WILL be applied.

  Throws:
    `SchedulerException`
  See Also:
    `resumeAll()`, `pauseTriggers(org.quartz.impl.matchers.GroupMatcher)`, `standby()`

### resumeAll

    void resumeAll()
                   throws SchedulerException

  Resume (un-pause) all triggers - similar to calling `resumeTriggerGroup(group)` on every group.

  If any `Trigger` missed one or more fire-times, then the `Trigger`'s misfire instruction will be applied.

  Throws:
    `SchedulerException`
  See Also:
    `pauseAll()`

### getJobGroupNames

    List<String> getJobGroupNames()
                                  throws SchedulerException

  Get the names of all known ``JobDetail`` groups.

  Throws:
    `SchedulerException`

### getJobKeys

    Set<JobKey> getJobKeys(GroupMatcher<JobKey> matcher)
                           throws SchedulerException

  Get the keys of all the ``JobDetail`s` in the matching groups.

  Parameters:
    `matcher` - Matcher to evaluate against known groups
  Returns:
    Set of all keys matching
  Throws:
    `SchedulerException` - On error

### getTriggersOfJob

    List<? extends Trigger> getTriggersOfJob(JobKey jobKey)
                                             throws SchedulerException

  Get all ``Trigger`` s that are associated with the identified ``JobDetail``.

  The returned Trigger objects will be snap-shots of the actual stored triggers. If you wish to modify a trigger, you must re-store the trigger afterward (e.g. see `rescheduleJob(TriggerKey, Trigger)`).

  Throws:
    `SchedulerException`

### getTriggerGroupNames

    List<String> getTriggerGroupNames()
                                      throws SchedulerException

  Get the names of all known ``Trigger`` groups.

  Throws:
    `SchedulerException`

### getTriggerKeys

    Set<TriggerKey> getTriggerKeys(GroupMatcher<TriggerKey> matcher)
                                   throws SchedulerException

  Get the names of all the ``Trigger`s` in the given group.

  Parameters:
    `matcher` - Matcher to evaluate against known groups
  Returns:
    List of all keys matching
  Throws:
    `SchedulerException` - On error

### getPausedTriggerGroups

    Set<String> getPausedTriggerGroups()
                                       throws SchedulerException

  Get the names of all ``Trigger`` groups that are paused.

  Throws:
    `SchedulerException`

### getJobDetail

    JobDetail getJobDetail(JobKey jobKey)
                           throws SchedulerException

  Get the ``JobDetail`` for the `Job` instance with the given key.

  The returned JobDetail object will be a snap-shot of the actual stored JobDetail. If you wish to modify the JobDetail, you must re-store the JobDetail afterward (e.g. see `addJob(JobDetail, boolean)`).

  Throws:
    `SchedulerException`

### getTrigger

    Trigger getTrigger(TriggerKey triggerKey)
                       throws SchedulerException

  Get the ``Trigger`` instance with the given key.

  The returned Trigger object will be a snap-shot of the actual stored trigger. If you wish to modify the trigger, you must re-store the trigger afterward (e.g. see `rescheduleJob(TriggerKey, Trigger)`).

  Throws:
    `SchedulerException`

### getTriggerState

    Trigger.TriggerState getTriggerState(TriggerKey triggerKey)
                                         throws SchedulerException

  Get the current state of the identified ``Trigger``.

  Throws:
    `SchedulerException`
  See Also:
    `Trigger.TriggerState`

### addCalendar

    void addCalendar(String calName,
                     Calendar calendar,
                     boolean replace,
                     boolean updateTriggers)
                     throws SchedulerException

  Add (register) the given `Calendar` to the Scheduler.

  Parameters:
    `updateTriggers` - whether or not to update existing triggers that referenced the already existing calendar so that they are 'correct' based on the new trigger.
  Throws:
    `SchedulerException` - if there is an internal Scheduler error, or a Calendar with the same name already exists, and `replace` is `false`.

### deleteCalendar

    boolean deleteCalendar(String calName)
                           throws SchedulerException

  Delete the identified `Calendar` from the Scheduler.

  If removal of the `Calendar` would result in `Trigger`s pointing to non-existent calendars, then a `SchedulerException` will be thrown.

  Returns:
    true if the Calendar was found and deleted.
  Throws:
    `SchedulerException` - if there is an internal Scheduler error, or one or more triggers reference the calendar

### getCalendar

    Calendar getCalendar(String calName)
                         throws SchedulerException

  Get the ``Calendar`` instance with the given name.

  Throws:
    `SchedulerException`

### getCalendarNames

    List<String> getCalendarNames()
                                  throws SchedulerException

  Get the names of all registered ``Calendar`s`.

  Throws:
    `SchedulerException`

### interrupt

    boolean interrupt(JobKey jobKey)
                      throws UnableToInterruptJobException

  Request the interruption, within this Scheduler instance, of all currently executing instances of the identified `Job`, which must be an implementor of the `InterruptableJob` interface.

  If more than one instance of the identified job is currently executing, the `InterruptableJob#interrupt()` method will be called on each instance. However, there is a limitation that in the case that `interrupt()` on one instances throws an exception, all remaining instances (that have not yet been interrupted) will not have their `interrupt()` method called.

  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.

  Returns:
    true if at least one instance of the identified job was found and interrupted.
  Throws:
    `UnableToInterruptJobException` - if the job does not implement `InterruptableJob`, or there is an exception while interrupting the job.
  See Also:
    `InterruptableJob.interrupt()`, `getCurrentlyExecutingJobs()`, `interrupt(String)`

### interrupt

    boolean interrupt(String fireInstanceId)
                      throws UnableToInterruptJobException

  Request the interruption, within this Scheduler instance, of the identified executing `Job` instance, which must be an implementor of the `InterruptableJob` interface.

  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.

  Parameters:
    `fireInstanceId` - the unique identifier of the job instance to be interrupted (see `JobExecutionContext.getFireInstanceId()`
  Returns:
    true if the identified job instance was found and interrupted.
  Throws:
    `UnableToInterruptJobException` - if the job does not implement `InterruptableJob`, or there is an exception while interrupting the job.
  See Also:
    `InterruptableJob.interrupt()`, `getCurrentlyExecutingJobs()`, `JobExecutionContext.getFireInstanceId()`, `interrupt(JobKey)`

### checkExists

    boolean checkExists(JobKey jobKey)
                        throws SchedulerException

  Determine whether a `Job` with the given identifier already exists within the scheduler.

  Parameters:
    `jobKey` - the identifier to check for
  Returns:
    true if a Job exists with the given identifier
  Throws:
    `SchedulerException`

### checkExists

    boolean checkExists(TriggerKey triggerKey)
                        throws SchedulerException

  Determine whether a `Trigger` with the given identifier already exists within the scheduler.

  Parameters:
    `triggerKey` - the identifier to check for
  Returns:
    true if a Trigger exists with the given identifier
  Throws:
    `SchedulerException`

### clear

    void clear()
               throws SchedulerException

  Clears (deletes!) all scheduling data - all `Job`s, `Trigger`s `Calendar`s.

  Throws:
    `SchedulerException`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright 2001-2016, Terracotta, Inc.