Executors.newScheduledThreadPool
实际返回类型:
/**
* Creates a thread pool that can schedule commands to run after a
* given delay, or to execute periodically.
* @param corePoolSize the number of threads to keep in the pool,
* even if they are idle
* @return a newly created scheduled thread pool
* @throws IllegalArgumentException if {@code corePoolSize < 0}
*/
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
/**
* Creates a thread pool that can schedule commands to run after a
* given delay, or to execute periodically.
* @param corePoolSize the number of threads to keep in the pool,
* even if they are idle
* @param threadFactory the factory to use when the executor
* creates a new thread
* @return a newly created scheduled thread pool
* @throws IllegalArgumentException if {@code corePoolSize < 0}
* @throws NullPointerException if threadFactory is null
*/
public static ScheduledExecutorService newScheduledThreadPool(
int corePoolSize, ThreadFactory threadFactory) {
return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
}
实例
scheduleAtFixedRate方法:
-
initialDelay设置方法第一次执行前的延时时间, 设置为0即马上就执行. -
period用于控制后续的重复执行.
该方法的计时从前一次执行的开始计时. 比如说第一次执行是在第1秒,period为1秒, 那么第二次执行将会在第2秒开始, 第3次执行将会在第3秒开始... 如果出现某次任务的执行时长超过period, 那么需要等待这次执行完成才会开始下一次.
即该方法的下一次执行时间为max(上一次执行需要花的时间, period). - 如果某次执行过程中抛出了
exception, 那么后续的执行将不会再继续了.
/**
* Creates and executes a periodic action that becomes enabled first
* after the given initial delay, and subsequently with the given
* period; that is executions will commence after
* {@code initialDelay} then {@code initialDelay+period}, then
* {@code initialDelay + 2 * period}, and so on.
* If any execution of the task
* encounters an exception, subsequent executions are suppressed.
* Otherwise, the task will only terminate via cancellation or
* termination of the executor. If any execution of this task
* takes longer than its period, then subsequent executions
* may start late, but will not concurrently execute.
*
* @param command the task to execute
* @param initialDelay the time to delay first execution
* @param period the period between successive executions
* @param unit the time unit of the initialDelay and period parameters
* @return a ScheduledFuture representing pending completion of
* the task, and whose {@code get()} method will throw an
* exception upon cancellation
* @throws RejectedExecutionException if the task cannot be
* scheduled for execution
* @throws NullPointerException if command is null
* @throws IllegalArgumentException if period less than or equal to zero
*/
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
long initialDelay,
long period,
TimeUnit unit);
实例:
public static void testScheduleAtFixedRate(){
Runnable runnable = new Runnable() {
@Override
public void run() {
try {
System.out.println("working at: " + getCurrentTime());
Thread.sleep(2000);
} catch (InterruptedException e) {
}
}
};
ScheduledFuture<?> future = scheduledExecutorService.scheduleAtFixedRate(runnable, 0, 1000, TimeUnit.MILLISECONDS);
Thread main = Thread.currentThread();
scheduledExecutorService.schedule(()-> main.interrupt(), 5000, TimeUnit.MILLISECONDS);
try {
future.get();
} catch (InterruptedException | ExecutionException e) {
future.cancel(true);
}
}
输出:
working at: 23:07:17
working at: 23:07:19
working at: 23:07:21
从输出可以看出, 第一次执行开始于23:07:17, 按照period参数1000, 第二次执行应该是在23:07:18, 但是实际是在23:07:19, 因为任务执行一次需要2000毫秒, 所以即使period计时满足了, 仍然要等待前一次执行完成, 才会执行下一次.
scheduleWithFixedDelay方法
注释:
/**
* Creates and executes a periodic action that becomes enabled first
* after the given initial delay, and subsequently with the
* given delay between the termination of one execution and the
* commencement of the next. If any execution of the task
* encounters an exception, subsequent executions are suppressed.
* Otherwise, the task will only terminate via cancellation or
* termination of the executor.
*
* @param command the task to execute
* @param initialDelay the time to delay first execution
* @param delay the delay between the termination of one
* execution and the commencement of the next
* @param unit the time unit of the initialDelay and delay parameters
* @return a ScheduledFuture representing pending completion of
* the task, and whose {@code get()} method will throw an
* exception upon cancellation
* @throws RejectedExecutionException if the task cannot be
* scheduled for execution
* @throws NullPointerException if command is null
* @throws IllegalArgumentException if delay less than or equal to zero
*/
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
long initialDelay,
long delay,
TimeUnit unit);
与scheduleAtFixedRate不同的是, scheduleWithFixedDelay方法的delay计时开始于上一次执行结束. 即下一次执行的时间为上一次执行完毕后再过delay时间.
实例:
public static void testScheduleWithFixedDelay(){
Runnable runnable = new Runnable() {
@Override
public void run() {
try {
System.out.println("working at: " + getCurrentTime());
Thread.sleep(2000);
} catch (InterruptedException e) {
}
}
};
ScheduledFuture<?> future = scheduledExecutorService.scheduleWithFixedDelay(runnable, 0, 2000, TimeUnit.MILLISECONDS);
Thread main = Thread.currentThread();
scheduledExecutorService.schedule(() -> main.interrupt(), 10, TimeUnit.SECONDS);
try {
future.get();
} catch (InterruptedException | ExecutionException e) {
future.cancel(true);
}
}
输出:
working at: 23:12:07
working at: 23:12:11
working at: 23:12:15
可以看出下一次执行都是在上一次执行完毕后的2000毫秒后 (注意一次执行花费2000毫秒).
