周期性线程池Executors.newScheduledThreadPool
目录
- newScheduledThreadPool的作用
- 构造方法
- newScheduledThreadPool常用方法demo
-
- 周期执行：scheduleAtFixedRate()
-
- 方法功能：
- 执行Demo：
- 执行结果：
- 周期执行：scheduleWithFixedDelay()
-
- 方法功能：
- 执行Demo：
- 执行结果：
- 延迟执行：schedule()
-
- 方法功能：
- 执行Demo：
- 执行结果：
- 延迟执行并返回结果：schedule()
-
- 方法功能：
- 执行Demo：
- 执行结果：
- 延迟执行并返回结果：submit()
-
- 方法功能：
- 执行Demo：
- 执行结果：
newScheduledThreadPool的作用
常用于需要延迟执行或周期循环执行任务的场景
构造方法
ScheduledExecutorService java.util.concurrent.Executors.newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)
该方法只有两个参数，一个是核心池的大小。另一个是线程工厂。
newScheduledThreadPool常用方法demo
下面的所有的测试demo都使用静态对象，就不重复定义了：
static ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);
周期执行：scheduleAtFixedRate()
方法功能：
scheduleAtFixedRate(command, 5, 2, second):
第一次开始执行是5s后，假如执行耗时1s，那么下次开始执行是7s后，再下次开始执行是9s后。
如果执行耗时>等待时间，那么将会在任务执行完成后立马开始执行下一轮任务。
如果执行耗时<等待时间，那么将会在任务执行完成后等待【等待时间-执行耗时】，然后再执行下一轮任务
执行Demo：
@Test
public void test_scheduleAtFixedRate() throws InterruptedException {
System.out.println("scheduleAtFixedRate-start:" + new Date());
// scheduleAtFixedRate(command, 5, 2, second)，
// 第一次开始执行是5s后，假如执行耗时1s，那么下次开始执行是7s后，再下次开始执行是9s后
// 如果执行耗时>等待时间，那么将会在任务执行完成后立马开始执行下一轮任务。
// 如果执行耗时<等待时间，那么将会在任务执行完成后等待【等待时间-执行耗时】，然后再执行下一轮任务
pool.scheduleAtFixedRate(() -> {
try {
Thread.sleep(1000L);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("scheduleAtFixedRate:" + new Date());
}, 5, 2, TimeUnit.SECONDS);
Thread.sleep(100000L);
}
执行结果：
启动后延迟5秒，然后每2秒执行一次。
周期执行：scheduleWithFixedDelay()
方法功能：
scheduleWithFixedDelay(command, 5, 2, second):
第一次开始执行是5s后，假如执行耗时1s，执行完成时间是6s后，那么下次开始执行是8s后，再下次开始执行是11s后。
它会在任务执行完成后再等待2秒
执行Demo：
@Test
public void test_scheduleWithFixedDelay() throws InterruptedException {
System.out.println("scheduleAtFixedRate-start:" + new Date());
// scheduleWithFixedDelay(command, 5, 2, second)，
// 第一次开始执行是5s后，假如执行耗时1s，执行完成时间是6s后，那么下次开始执行是8s后，再下次开始执行是11s后
// 它会在任务执行完成后再等待2秒
pool.scheduleWithFixedDelay(() -> {
try {
Thread.sleep(1000L);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("scheduleAtFixedRate:" + new Date());
}, 5, 2, TimeUnit.SECONDS);
Thread.sleep(100000L);
}
执行结果：
启动后延迟5秒，然后每1（执行耗时）+2（等待时间）秒执行一次。
延迟执行：schedule()
方法功能：
ScheduledFuture<?> java.util.concurrent.ScheduledExecutorService.schedule(Runnable command, long delay, TimeUnit unit)
在给定的时间之后执行一次。
执行Demo：
@Test
public void test_schedule() throws InterruptedException {
System.out.println("schedule-start:" + new Date());
// 在给定的延迟后执行一次
pool.schedule(() -> {
System.out.println("schedule:" + new Date());
}, 2, TimeUnit.SECONDS);
Thread.sleep(100000L);
}
执行结果：
在2秒钟后执行一次任务，执行完成就结束。
延迟执行并返回结果：schedule()
方法功能：
ScheduledFuture<?> java.util.concurrent.ScheduledExecutorService.schedule(Runnable command, long delay, TimeUnit unit)
在给定的延迟后执行一次，并阻塞线程等待结果返回
执行Demo：
@Test
public void test_ScheduledFuture() throws InterruptedException, ExecutionException {
System.out.println("schedule-future-start:" + new Date());
// 在给定的延迟后执行一次，并返回结果
ScheduledFuture<Date> future = pool.schedule(() -> {
return new Date();
}, 2, TimeUnit.SECONDS);
System.out.println("schedule-future:" + future.get());
}
执行结果：
在2秒钟后执行一次任务，线程阻塞等待结果返回。执行完成并返回结果后就结束。
延迟执行并返回结果：submit()
方法功能：
在给定的延迟后执行一次，并阻塞线程等待结果返回，可以将一个对象作为参数传递，执行完成后，再将该对象返回。该对象默认是final的。
执行Demo：
@Test
public void test_submitFuture() throws InterruptedException, ExecutionException {
System.out.println("schedule-start:" + new Date());
// 把要返回的对象传递过去，在执行完成后再返回
Map<String,String> result = new HashMap<String, String>();
Future<Map<String,String>> future2 = pool.submit(() -> {
try {
Thread.sleep(1000L);
} catch (Exception e) {
e.printStackTrace();
}
result.put("result", "任务执行完成啦");
System.out.println("schedule:" + new Date());
}, result);
System.out.println("执行完成，返回指定的值:" + future2.get());
}
执行结果：
将一个空map作为参数传递。在执行时，向该map对象添加参数，执行完成后，将该对象返回。
