MIDletStateHandler for security checks. The functionality of the Scheduler was moved to the {@link MIDletStateHandler}
Timer object to build events firing plan. Using this class it is possible to scheduler big number of events related to different channels with individual period and priority settings. It is also possible to unsechedule processing of channels, reschedule to another period and request immediate firing of processing event with consequent rebuilding of events plan.
@author Aleksey Gureev (spyromus@noizeramp.com)
The cron4j scheduler.
@author Carlo PellicciaaddRunnable and removeRunnable methods. Recipes are supplied using configuration properties using the updated method, or are passed in the task's properties.Runnable and a recipe are available for it.
This class is thread-safe
@author George Gastaldi (gastaldi)
An scheduler is a class that arrange jobs in a define schedule. Once the Scheduler starts it launch a thread that triggers an action, when stopped, that action is not executed anymore, unless it is scheduled on demand by the method {@link org.mule.api.schedule.Scheduler#schedule()}
The initialization of a Scheduler is thought to be the stage where it reserves resources to schedule. While the dispose phase is thought to be the stage where those resources are released.
This interface implements {@link NameableObject} the name of the Scheduler is used as its identifier in the{@link org.mule.api.registry.MuleRegistry}
The recommended way to create a Scheduler is by a {@link SchedulerFactory}, this will allow other users to hook the Scheduler creation. This can me omitted if this is not desired.
Each scheduler is thought to schedule a single job. Check the {@link SchedulerFactory#create(String,Object)} to see thecreation of the scheduler for more details.
@since 3.5.0This is the main interface of a Quartz Scheduler.
A Scheduler maintains a registry of {@link org.quartz.JobDetail} s and {@link 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 {@link 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 Jobs.
Job s are to be created by the 'client program', by defining a class that implements the {@link org.quartz.Job} interface. {@link 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 {@link Scheduler}. The 'group' feature may be useful for creating logical groupings or categorizations of Jobs s and Triggerss. 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 {@link JobListener} interface provides notifications of Job executions. The {@link TriggerListener} interface provides notifications of Trigger firings. The {@link SchedulerListener} interface provides notifications of Scheduler events and errors.
The setup/configuration of a Scheduler instance is very customizable. Please consult the documentation distributed with Quartz.
Scheduler object is used to schedule tasks for execution. This queues the task for the requested period of time before it is executed. It ensures that the delay is adhered to such that tasks can be timed for execution in an accurate way.
@author Niall Gallagher
A scheduler is contained by a StaticSchedulingDirector, and provides the schedule for it. The director will use this schedule to govern the execution of a CompositeActor.
A schedule is represented by the Schedule class, and determines the order of the firing of the actors in a particular composite actor. In this base class, the default schedule fires the deeply contained actors in the order of their construction. A domain specific scheduler will override this to provide a different order.
The schedule, once constructed, is cached and reused as long as the schedule is still valid. The validity of the schedule is set by the setValid() method. If the current schedule is not valid, then the schedule will be recomputed the next time the getSchedule() method is called. However, derived classes will usually override only the protected _getSchedule() method.
The scheduler does not perform any mutations, and it does not listen for changes in the model. Directors that use this scheduler should normally invalidate the schedule when mutations occur. @author Jie Liu, Steve Neuendorffer @version $Id: Scheduler.java,v 1.81 2005/10/29 01:14:33 cxh Exp $ @since Ptolemy II 0.2 @Pt.ProposedRating Green (neuendor) @Pt.AcceptedRating Yellow (neuendor) @see ptolemy.actor.sched.Schedule
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |