This class extends ThreadPoolExecutor to implement the methods of the ScheduledExecutorService interface to allow tasks to be submitted for execution once or repeatedly at some scheduled time in the future. Instances of this class are usually obtained through the static factory methods of the Executors utility class. You can also explicitly create one with the ScheduledThreadPoolExecutors( ) constructor. ScheduledThreadPoolExecutor always creates its own unbounded work queue, which means that you cannot pass a queue to the constructor. Also, there is no need to specify a maximumPoolSize since this configuration parameter is irrelevant with unbounded queues.

Note that tasks submitted to a ScheduledThreadPoolExecutor are not guaranteed to run at the scheduled time. That is the time at which they first become eligible to run. If all threads are busy with other tasks, however, eligible tasks may get queued up to run later.

This class provides functionality similar to java.util.Timer but adds multithreaded capability and the ability to work with Callable and Future objects.

Figure 16-91. java.util.concurrent.ScheduledThreadPoolExecutor

public class ScheduledThreadPoolExecutor extends ThreadPoolExecutor 
        implements ScheduledExecutorService {
// Public Constructors
     public ScheduledThreadPoolExecutor(int corePoolSize);  
     public ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory);  
     public ScheduledThreadPoolExecutor(int corePoolSize, RejectedExecutionHandler handler);  
     public ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory,
 RejectedExecutionHandler handler);  
// Public Instance Methods
     public boolean getContinueExistingPeriodicTasksAfterShutdownPolicy( );  
     public boolean getExecuteExistingDelayedTasksAfterShutdownPolicy( );  
     public void setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean value);  
     public void setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean value);  
// Methods Implementing Executor
     public void execute(Runnable command);  
// Methods Implementing ExecutorService
     public void shutdown( );  
     public java.util.List<Runnable> shutdownNow( );  
     public Future<?> submit(Runnable task);  
     public <T> Future<T> submit(Callable<T> task);  
     public <T> Future<T> submit(Runnable task, T result);  
// Methods Implementing ScheduledExecutorService
     public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit);  
     public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);  
     public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, 
        long period, TimeUnit unit);  
     public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, 
        long delay, TimeUnit unit);  
// Public Methods Overriding ThreadPoolExecutor
     public BlockingQueue<Runnable> getQueue( );  
     public boolean remove(Runnable task);  
}