周期性线程池Executors.newScheduledThreadPool

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()

方法功能：

<T> Future<T> submit(Runnable task, T result)：
在给定的延迟后执行一次，并阻塞线程等待结果返回，可以将一个对象作为参数传递，执行完成后，再将该对象返回。该对象默认是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对象添加参数，执行完成后，将该对象返回。