/* * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/publicdomain/zero/1.0/ */ package java.util.concurrent; /** * An {@link ExecutorService} that can schedule commands to run after a given * delay, or to execute periodically. * *
The {@code schedule} methods create tasks with various delays * and return a task object that can be used to cancel or check * execution. The {@code scheduleAtFixedRate} and * {@code scheduleWithFixedDelay} methods create and execute tasks * that run periodically until cancelled. * *
Commands submitted using the {@link Executor#execute} and * {@link ExecutorService} {@code submit} methods are scheduled with * a requested delay of zero. Zero and negative delays (but not * periods) are also allowed in {@code schedule} methods, and are * treated as requests for immediate execution. * *
All {@code schedule} methods accept relative delays and * periods as arguments, not absolute times or dates. It is a simple * matter to transform an absolute time represented as a {@link * java.util.Date} to the required form. For example, to schedule at * a certain future {@code date}, you can use: {@code schedule(task, * date.getTime() - System.currentTimeMillis(), * TimeUnit.MILLISECONDS)}. Beware however that expiration of a * relative delay need not coincide with the current {@code Date} at * which the task is enabled due to network time synchronization * protocols, clock drift, or other factors. * * The {@link Executors} class provides convenient factory methods for * the ScheduledExecutorService implementations provided in this package. * *
{@code * import static java.util.concurrent.TimeUnit.*; * class BeeperControl { * private final ScheduledExecutorService scheduler = * Executors.newScheduledThreadPool(1); * * public void beepForAnHour() { * final Runnable beeper = new Runnable() { * public void run() { System.out.println("beep"); } * }; * final ScheduledFuture> beeperHandle = * scheduler.scheduleAtFixedRate(beeper, 10, 10, SECONDS); * scheduler.schedule(new Runnable() { * public void run() { beeperHandle.cancel(true); } * }, 60 * 60, SECONDS); * } * }}* * @since 1.5 * @author Doug Lea */ public interface ScheduledExecutorService extends ExecutorService { /** * Creates and executes a one-shot action that becomes enabled * after the given delay. * * @param command the task to execute * @param delay the time from now to delay execution * @param unit the time unit of the delay parameter * @return a ScheduledFuture representing pending completion of * the task and whose {@code get()} method will return * {@code null} upon completion * @throws RejectedExecutionException if the task cannot be * scheduled for execution * @throws NullPointerException if command is null */ public ScheduledFuture> schedule(Runnable command, long delay, TimeUnit unit); /** * Creates and executes a ScheduledFuture that becomes enabled after the * given delay. * * @param callable the function to execute * @param delay the time from now to delay execution * @param unit the time unit of the delay parameter * @return a ScheduledFuture that can be used to extract result or cancel * @throws RejectedExecutionException if the task cannot be * scheduled for execution * @throws NullPointerException if callable is null */ public