Timerpublic class Timer extends Object | {@code Timer}s are used to schedule jobs for execution in a background process. A
single thread is used for the scheduling and this thread has the option of
being a daemon thread. By calling {@code cancel} you can terminate a
{@code Timer} and its associated thread. All tasks which are scheduled to run after
this point are cancelled. Tasks are executed sequentially but are subject to
the delays from other tasks run methods. If a specific task takes an
excessive amount of time to run it may impact the time at which subsequent
tasks may run.
The {@code TimerTask} does not offer any guarantees about the real-time nature of
scheduling tasks as its underlying implementation relies on the
{@code Object.wait(long)} method.
Multiple threads can share a single {@code Timer} without the need for their own
synchronization.
A {@code Timer} can be set to schedule tasks either at a fixed rate or
with a fixed period. Fixed-period execution is the default.
The difference between fixed-rate and fixed-period execution
is the following: With fixed-rate execution, the start time of each
successive run of the task is scheduled in absolute terms without regard for when the previous
task run actually took place. This can result in a series of bunched-up runs
(one launched immediately after another) if busy resources or other
system delays prevent the {@code Timer} from firing for an extended time.
With fixed-period execution, each successive run of the
task is scheduled relative to the start time of the previous run of the
task, so two runs of the task are never fired closer together in time than
the specified {@code period}.
|
| Fields Summary |
|---|
| private TimerImpl | impl | | private Object | finalizer |
| Constructors Summary |
|---|
public Timer(boolean isDaemon)Creates a new {@code Timer} which may be specified to be run as a daemon thread.
// BEGIN android-changed
impl = new TimerImpl("java.util.Timer", isDaemon);
// END android-changed
| public Timer()Creates a new non-daemon {@code Timer}.
// BEGIN android-changed
impl = new TimerImpl("java.util.Timer", false);
// END android-changed
| public Timer(String name, boolean isDaemon)Creates a new named {@code Timer} which may be specified to be run as a
daemon thread.
impl = new TimerImpl(name, isDaemon);
| public Timer(String name)Creates a new named {@code Timer} which does not run as a daemon thread.
impl = new TimerImpl(name, false);
|
| Methods Summary |
|---|
| public void | cancel()Cancels the {@code Timer} and removes any scheduled tasks. If there is a
currently running task it is not affected. No more tasks may be scheduled
on this {@code Timer}. Subsequent calls do nothing.
impl.cancel();
| | public int | purge()Removes all canceled tasks from the task queue. If there are no
other references on the tasks, then after this call they are free
to be garbage collected.
synchronized (impl) {
return impl.purge();
}
| | public void | schedule(java.util.TimerTask task, java.util.Date when, long period)Schedule a task for repeated fixed-delay execution after a specific time
has been reached.
if (period <= 0 || when.getTime() < 0) {
throw new IllegalArgumentException();
}
long delay = when.getTime() - System.currentTimeMillis();
scheduleImpl(task, delay < 0 ? 0 : delay, period, false);
| | public void | schedule(java.util.TimerTask task, java.util.Date when)Schedule a task for single execution. If {@code when} is less than the
current time, it will be scheduled to be executed as soon as possible.
if (when.getTime() < 0) {
throw new IllegalArgumentException();
}
long delay = when.getTime() - System.currentTimeMillis();
scheduleImpl(task, delay < 0 ? 0 : delay, -1, false);
| | public void | schedule(java.util.TimerTask task, long delay)Schedule a task for single execution after a specified delay.
if (delay < 0) {
throw new IllegalArgumentException();
}
scheduleImpl(task, delay, -1, false);
| | public void | schedule(java.util.TimerTask task, long delay, long period)Schedule a task for repeated fixed-delay execution after a specific delay.
if (delay < 0 || period <= 0) {
throw new IllegalArgumentException();
}
scheduleImpl(task, delay, period, false);
| | public void | scheduleAtFixedRate(java.util.TimerTask task, long delay, long period)Schedule a task for repeated fixed-rate execution after a specific delay
has passed.
if (delay < 0 || period <= 0) {
throw new IllegalArgumentException();
}
scheduleImpl(task, delay, period, true);
| | public void | scheduleAtFixedRate(java.util.TimerTask task, java.util.Date when, long period)Schedule a task for repeated fixed-rate execution after a specific time
has been reached.
if (period <= 0 || when.getTime() < 0) {
throw new IllegalArgumentException();
}
long delay = when.getTime() - System.currentTimeMillis();
scheduleImpl(task, delay < 0 ? 0 : delay, period, true);
| | private void | scheduleImpl(java.util.TimerTask task, long delay, long period, boolean fixed)Schedule a task.
synchronized (impl) {
if (impl.cancelled) {
throw new IllegalStateException(Msg.getString("K00f3")); //$NON-NLS-1$
}
long when = delay + System.currentTimeMillis();
if (when < 0) {
throw new IllegalArgumentException(Msg.getString("K00f5")); //$NON-NLS-1$
}
synchronized (task.lock) {
if (task.isScheduled()) {
throw new IllegalStateException(Msg.getString("K00f6")); //$NON-NLS-1$
}
if (task.cancelled) {
throw new IllegalStateException(Msg.getString("K00f7")); //$NON-NLS-1$
}
task.when = when;
task.period = period;
task.fixedRate = fixed;
}
// insert the newTask into queue
impl.insertTask(task);
}
|
|
