Java Concurrency 简明教程

ScheduledThreadPoolExecutor Class

java.util.concurrent.ScheduledThreadPoolExecutor 是 ThreadPoolExecutor 的一个子类，它还可以计划命令在给定的延迟后运行，或者定期执行。

ScheduledThreadPoolExecutor Methods

Sr.No.	Method & Description
1	protected <V> RunnableScheduledFuture<V> decorateTask(Callable<V> callable, RunnableScheduledFuture<V> task) 修改或替换用于执行可调用的任务。
2	protected <V> RunnableScheduledFuture<V> decorateTask(Runnable runnable, RunnableScheduledFuture<V> task) 修改或替换用于执行可运行的任务。
3	void execute(Runnable command) 以零所需延迟执行命令。
4	boolean getContinueExistingPeriodicTasksAfterShutdownPolicy() 获取即使此执行器已关闭也继续执行现有周期性任务的策略。
5	boolean getExecuteExistingDelayedTasksAfterShutdownPolicy() 获取即使此执行器已关闭也执行现有延迟任务的策略。
6	BlockingQueue<Runnable> getQueue() 返回值执行器使用的任务队列。
7	boolean getRemoveOnCancelPolicy() 获取取消的任务是否应该在取消时立即从工作队列中移除的策略。
8	<V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) 创建和执行一个 ScheduledFuture，该 ScheduledFuture 在给定的延迟后才启用。
9	ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) 创建和执行一个一次性操作，该操作在给定的延迟后才启用。
10	ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) 创建和执行一个周期性操作，该操作在给定的初始延迟后才首次启用，随后在给定的周期内启用；即执行将在 initialDelay、initialDelay+period、initialDelay + 2 * period 等时间点后开始。
11	ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) 在给定的初始延迟后首次启用，在一次执行终止与下一次执行开始之间有给定延迟的周期性操作。
12	void setContinueExistingPeriodicTasksAfterShutdownPolicy (boolean value) 设置即使此执行器已关闭也继续执行现有周期性任务的策略。
13	void setExecuteExistingDelayedTasksAfterShutdownPolicy (boolean value) 设置即使此执行器已关闭也执行现有延迟任务的策略。
14	void setRemoveOnCancelPolicy(boolean value) 设置取消的任务是否应该在取消时立即从工作队列中移除的策略。
15	void shutdown() 启动有序关闭，其中已提交的任务执行，但不会接纳新任务。
16	List<Runnable> shutdownNow() 尝试停止所有正在积极执行的任务，停止处理等待的任务，并返回等待执行的任务的列表。
17	<T> Future<T> submit(Callable<T> task) 提交一个返回值的的任务以执行，并返回一个表示任务的待处理结果的 Future。
18	Future<?> submit(Runnable task) 提交一个可运行的任务以执行，并返回一个表示该任务的 Future。
19	<T> Future<T> submit(Runnable task, T result) 提交一个可运行的任务以执行，并返回一个表示该任务的 Future。

Example

以下 TestThread 程序展示了在基于线程的环境中使用 ScheduledThreadPoolExecutor 接口。

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

public class TestThread {

   public static void main(final String[] arguments) throws InterruptedException {
      final ScheduledThreadPoolExecutor scheduler =
         (ScheduledThreadPoolExecutor)Executors.newScheduledThreadPool(1);

      final ScheduledFuture<?> beepHandler =
         scheduler.scheduleAtFixedRate(new BeepTask(), 2, 2, TimeUnit.SECONDS);

      scheduler.schedule(new Runnable() {

         @Override
         public void run() {
            beepHandler.cancel(true);
            scheduler.shutdown();
         }
      }, 10, TimeUnit.SECONDS);
   }

   static class BeepTask implements Runnable {

      public void run() {
         System.out.println("beep");
      }
   }
}

这将产生以下结果。

Output

beep
beep
beep
beep