Executors框架之ScheduledExecutorService实现定时任务

一、简介

An ExecutorService that can schedule commands to run after a given delay, or to execute periodically.

(ExecutorService可以安排命令在给定的延迟后运行或定期执行。)

The schedule methods create tasks with various delays and return a task object that can be used to cancel or check execution. The scheduleAtFixedRate and scheduleWithFixedDelay methods create and execute tasks that run periodically until cancelled.

(调度方法会创建具有各种延迟的任务，并返回可用于取消或检查执行的任务对象。 scheduleAtFixedRate和scheduleWithFixedDelay方法创建并执行定期运行的任务，直到被取消为止。

)

Commands submitted using the Executor.execute(java.lang.Runnable) and ExecutorService submit methods are scheduled with a requested delay of zero. Zero and negative delays (but not periods) are also allowed in schedule methods, and are treated as requests for immediate execution.

(使用Executor.execute（java.lang.Runnable）和ExecutorService提交方法提交的命令的计划延迟为零。调度方法中还允许零延迟和负延迟（但不允许使用周期），并将其视为立即执行的请求。

)

All 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 Date to the required form. For example, to schedule at a certain future date, you can use: schedule(task, date.getTime() - System.currentTimeMillis(), TimeUnit.MILLISECONDS). Beware however that expiration of a relative delay need not coincide with the current Date at which the task is enabled due to network time synchronization protocols, clock drift, or other factors. The Executors class provides convenient factory methods for the ScheduledExecutorService implementations provided in this package.

(所有调度方法都接受相对延迟和周期作为参数，而不是绝对时间或日期作为参数。将代表日期的绝对时间转换为所需的形式很简单。例如，要计划在某个将来的日期进行计划，可以使用：schedule（task，date.getTime（）-System.currentTimeMillis（），TimeUnit.MILLISECONDS）。但是请注意，由于网络时间同步协议，时钟漂移或其他因素，相对延迟的到期时间不必与启用任务的当前日期一致。 Executors类为此程序包中提供的ScheduledExecutorService实现提供了方便的工厂方法。

)

(jdk7 doc , translate by google )

二、两个常用定时任务

1. 固定周期的定时任务

ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)

创建并执行一个周期性操作，该操作将在给定的初始延迟后首先启用，然后在给定的时间段内启用；即后执行将开始 在initialDelay然后在initialDelay +周期，然后 在initialDelay + 2 *周期，依此类推。

2. 固定延迟的定时任务

ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)

创建并执行一个周期性操作，该操作将在给定的初始延迟后首先启用，然后在一个执行的终止与下一个执行的开始之间具有给定的延迟。

3. 一次性延迟任务 Runnable

ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)

创建并执行一次操作，该操作在给定的延迟后变为启用状态。

ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);
System.out.println("一次性的延迟任务, 10S 后执行");
executorService.schedule(new Runnable() {
    @Override
    public void run() {
        System.out.println("一次性延迟任务");
    }
}, 10L, SECONDS);

4. 一次性延迟任务 Callable

<V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit)

创建并执行ScheduledFuture，该ScheduledFuture在给定的延迟后变为启用状态。

三、示例代码

class PrintControl {
    private final SimpleDateFormat SDF = new SimpleDateFormat("hh:mm:ss");

    /**
     * @param int corePoolSize 线程池中最小的线程数, 无任务时保持, 任务过多时可以超出这个值
     */
    private final ScheduledExecutorService scheduled = Executors.newScheduledThreadPool(1);

    /**
     * 给定延迟的打印任务
     * 以固定的延迟时间(delay)去执行任务
     */
    public void printForDelay() {
        Runnable print = () -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("ScheduledWithFixedDelay" + SDF.format(new Date()));
        };

        /**
         * @param Runnable command
         * @param long initialDelay
         * @param long delay
         * @param TimeUnit unit
         */
        scheduled.scheduleWithFixedDelay(print, 0L, 5L, SECONDS);
    }

    /**
     * 定期去执行打印任务
     * 以固定的周期(period)去执行任务
     */
    public void printForRate() {
        Runnable print = () -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("ScheduledAtFixedRate" + SDF.format(new Date()));
        };

        /**
         * @param Runnable command
         * @param long initialDelay
         * @param long period
         * @param TimeUnit unit
         */
        scheduled.scheduleAtFixedRate(print, 0L, 5L, SECONDS);
    }

}

四、通过ThreadFactory 指定任务线程名称

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)

使用ThreadFactory设置明确的线程名称, 这样在调试的时候就可以很清晰的找到任务线程, 便于调试

参考 Executors.defaultThreadFactory()

class PrintControl {
    private final ScheduledExecutorService scheduled = Executors.newScheduledThreadPool(1, ExecutorsefaultThreadFactory());
}

class PrintThreadFactory implements ThreadFactory {

    @Override
    public Thread newThread(Runnable r) {
        return new Thread(r, "PrintThreadFactory");
    }
}

五、结束任务

1. 异常抛出

如果任务抛出异常会导致周期任务无法继续进行, 所以最好结合try cache处理.

此时线程不会结束.

final AtomicInteger count = new AtomicInteger(0);

ScheduledExecutorService schedule = Executors.newScheduledThreadPool(1, new PrintThreadFactory());

StringBuilder nullPoint = null;

Runnable print = new Runnable() {
    @Override
    public void run() {
        System.out.println("print " + count.getAndIncrement());
        // print 4 之后, 任务不再继续执行
        if (count.get() == 5) {
            nullPoint.toString();
        }
    }
};

schedule.scheduleAtFixedRate(print, 0L, 2L, SECONDS);

2. 结束任务

Future.cancle(boolean mayInterruptIfRunning)

通过Debugger可以看出, 只是任务结束了,线程还在继续wait

// 最终打印 "print 3"之后打印"is canclelled", 任务不再继续, 线程不被关闭

final AtomicInteger count = new AtomicInteger(0);
final CountDownLatch countDownLatch = new CountDownLatch(1);
Future future = null;
ScheduledExecutorService schedule = Executors.newScheduledThreadPool(1, new PrintThreadFactory());

Runnable print = new Runnable() {
    @Override
    public void run() {
        System.out.println("print " + count.getAndIncrement());
        if (count.get() == 3) {
            countDownLatch.countDown();
        }
    }
};

future = schedule.scheduleAtFixedRate(print, 0L, 2L, SECONDS);
try {
    countDownLatch.await();
    future.cancel(true);
    if (future.isCancelled()) {
        System.out.println("is canclelled");
    }
} catch (InterruptedException e) {
    e.printStackTrace();
}

3. 结束线程

3.1. void ExecutorService.shutdown();

Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted.

(启动有序关闭，在该关闭中执行先前提交的任务，但不接受任何新任务。)

final AtomicInteger count = new AtomicInteger(0);
final CountDownLatch countDownLatch = new CountDownLatch(1);
ScheduledExecutorService schedule = Executors.newScheduledThreadPool(1, new PrintThreadFactory());

Runnable print = new Runnable() {
    @Override
    public void run() {
        System.out.println("print " + count.getAndIncrement());
        if (count.get() == 3) {
            countDownLatch.countDown();
            System.out.println("任务还在继续...");
            try {
                Thread.sleep(3000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务结束");
        }
    }
};

schedule.scheduleAtFixedRate(print, 0L, 2L, SECONDS);
try {
    countDownLatch.await();
    schedule.shutdown();
    // schedule.shutdownNow();

    if (schedule.isShutdown()) {
        System.out.println("Schedule is shutdown");
    }
    // 阻塞
    if (schedule.awaitTermination(10L, SECONDS)) {
        System.out.println("termination");
    }
} catch (InterruptedException e) {
    e.printStackTrace();
}

打印结果：

print 0
print 1
print 2
任务还在继续...
Schedule is shutdown
任务结束
termination

3.2. List ExecutorService.shutdownNow();

Attempts to stop all actively executing tasks, halts the processing of waiting tasks, and returns a list of the tasks that were awaiting execution.

(尝试停止所有正在执行的任务，暂停正在等待的任务的处理，并返回正在等待执行的任务的列表。)

final AtomicInteger count = new AtomicInteger(0);
final CountDownLatch countDownLatch = new CountDownLatch(1);
ScheduledExecutorService schedule = Executors.newScheduledThreadPool(1, new PrintThreadFactory());

Runnable print = new Runnable() {
    @Override
    public void run() {
        System.out.println("print " + count.getAndIncrement());
        if (count.get() == 3) {
            countDownLatch.countDown();
            System.out.println("任务还在继续...");
            try {
                Thread.sleep(3000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务结束");
        }
    }
};

schedule.scheduleAtFixedRate(print, 0L, 2L, SECONDS);
try {
    countDownLatch.await();
    // schedule.shutdown();
    schedule.shutdownNow();

    if (schedule.isShutdown()) {
        System.out.println("Schedule is shutdown");
    }
    // 阻塞
    if (schedule.awaitTermination(10L, SECONDS)) {
        System.out.println("termination");
    }
} catch (InterruptedException e) {
    e.printStackTrace();
}

打印结果： 可以看出 Thread.sleep()发生了中断异常

print 0
print 1
print 2
任务还在继续...
Schedule is shutdown
java.lang.InterruptedException: sleep interrupted
    ...
任务结束
termination

3.3. boolean ExecutorService.awaitTermination(long timeout, TimeUnit unit)

Blocks until all tasks have completed execution after a shutdown request, or the timeout occurs, or the current thread is interrupted, whichever happens first.

(阻塞直到关闭请求后所有任务完成执行，或者发生超时，或者当前线程被中断（以先发生的为准）。)

六、参考

• Interface ScheduledExecutorService （jdk8 doc）
• Interface ExecutorService (jdk8 doc)