Java 是一个多线程编程语言，这意味着我们可以使用 Java 开发多线程程序。一个多线程程序包含两个或更多部分可以并发运行，每个部分可以同时处理不同的任务，从而充分利用可用资源，特别是在计算机拥有多个CPU的情况下。
根据定义，多任务是指多个进程共享共同的处理资源，如CPU。多线程扩展了多任务的概念，在单一应用程序内可以将特定操作细分为单独的线程。每个线程都可以并行运行。操作系统不仅在不同应用程序之间划分处理时间，还在应用程序内的每个线程之间进行划分。
多线程使你能够以一种方式编写程序，使得多个活动可以在同一程序中并发进行。
Java 提供了一个 java.util.concurrent.ScheduledExecutorService 接口，它是 ExecutorService 接口的一个子接口，并支持任务/线程的将来和/或周期性执行。以下是这个接口的一些重要且有用的方法：
ScheduledExecutorService 方法
| 序号 |
方法与描述 |
| 1 |
<V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) 创建并执行一个 ScheduledFuture，该任务将在指定延迟后启用。 |
| 2 |
ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) 创建并执行一个一次性操作，该操作将在指定延迟后启用。 |
| 3 |
ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) 创建并执行一个周期性的动作，该动作首次在指定的初始延迟后启用，随后按照给定的时间间隔重复执行。 |
| 4 |
ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) 创建并执行一个周期性的动作，该动作首次在指定的初始延迟后启用，随后在一次执行结束与下一次执行开始之间按照给定的时间间隔重复执行。 |
示例 1
下面的 TestThread 程序展示了如何在一个基于线程的环境中使用 ScheduledExecutorService 接口来调度一个任务，使其在 2 秒后以每 2 秒的间隔运行 10 秒钟，展示 scheduleAtFixedRate() 和 schedule() 方法的使用。
package com.tutorialspoint;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
public class TestThread {
public static void main(final String[] arguments) throws InterruptedException {
final ScheduledExecutorService scheduler = 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");
}
}
}
输出
beep
beep
beep
beep
beep
示例 2
下面的 TestThread 程序展示了如何在一个基于线程的环境中使用 ScheduledExecutorService 接口来调度一个任务，使其在 2 秒后以每 2 秒的间隔运行 10 秒钟，展示 scheduleWithFixedDelay() 和 schedule() 方法的使用。
package com.tutorialspoint;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
public class TestThread {
public static void main(final String[] arguments) throws InterruptedException {
final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
final ScheduledFuture<?> beepHandler =
scheduler.scheduleAtFixedDelay(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");
}
}
}
输出
beep
beep
beep
beep
示例 3
下面的 TestThread 程序展示了如何在一个基于线程的环境中使用 ScheduledExecutorService 接口来调度一个任务，使其在 2 秒后仅运行一次，并在 10 秒钟后取消任务，展示 schedule() 方法的使用。
package com.tutorialspoint;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
public class TestThread {
public static void main(final String[] arguments) throws InterruptedException {
final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
final ScheduledFuture<?> beepHandler =
scheduler.schedule(new BeepTask(), 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");
}
}
}
输出
beep