ScheduledExecutorService与ExecutorService区别

在 Java 并发编程中，ScheduledExecutorService 和 ExecutorService 是两个重要的接口，用于执行任务和任务调度。虽然它们都用于管理和执行任务，但在功能和用途上有一些区别。

ExecutorService

ExecutorService 是一个执行器服务接口，用于执行提交的任务。它提供了执行任务的方法，例如 submit() 和 invokeAll()，可以执行 Callable 或 Runnable 类型的任务，并返回 Future 对象来获取任务的执行结果。

以下是一个使用 ExecutorService 执行任务的示例代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorServiceExample {
    public static void main(String[] args) {
        // 创建一个具有5个线程的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        // 循环提交10个任务到线程池
        for (int i = 0; i < 10; i++) {
            // 创建一个任务对象，每个任务有一个唯一的任务ID
            Runnable task = new Task(i);
            
            // 提交任务到线程池执行
            executorService.submit(task);
        }

        // 关闭线程池
        executorService.shutdown();
    }
}

class Task implements Runnable {
    private int taskId;

    public Task(int taskId) {
        this.taskId = taskId;
    }

    @Override
    public void run() {
        // 执行任务时打印任务ID
        System.out.println("Task " + taskId + " executed");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

在上述示例中，我们使用 Executors.newFixedThreadPool() 方法创建了一个固定大小为 5 的线程池。然后，我们使用 submit() 方法提交了 10 个任务，每个任务都是一个 Runnable 对象。线程池会自动分配线程来执行这些任务。

ScheduledExecutorService

ScheduledExecutorService 是 ExecutorService 的子接口，它扩展了任务调度的功能。除了执行任务外，它还可以安排任务在将来的某个时间点或以固定的延迟周期性地执行。

以下是一个使用 ScheduledExecutorService 调度任务的示例代码：

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledExecutorServiceExample {
    public static void main(String[] args) {
        // 创建一个具有两个线程的ScheduledExecutorService
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(2);

        // 定义任务1，使用Lambda表达式打印"Task 1 executed"
        Runnable task1 = () -> System.out.println("Task 1 executed");
        
        // 使用scheduleAtFixedRate方法安排任务1以固定的速率执行
        // 初始延迟为0秒，每隔1秒执行一次
        executorService.scheduleAtFixedRate(task1, 0, 1, TimeUnit.SECONDS);

        // 定义任务2，使用Lambda表达式打印"Task 2 executed"
        Runnable task2 = () -> System.out.println("Task 2 executed");
        
        // 使用scheduleWithFixedDelay方法安排任务2以固定的延迟执行
        // 初始延迟为0秒，延迟时间为3秒
        executorService.scheduleWithFixedDelay(task2, 0, 3, TimeUnit.SECONDS);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

在上述示例中，我们创建了一个 ScheduledExecutorService，使用 Executors.newScheduledThreadPool() 方法创建了一个具有两个线程的线程池。然后，我们定义了两个任务 task1 和 task2，并使用 scheduleAtFixedRate() 和 scheduleWithFixedDelay() 方法安排它们的执行。这些方法允许我们在将来的某个时间点执行任务，或以固定的时间间隔执行任务。

总结：
ExecutorService 是一个用于执行提交的任务的接口，而 ScheduledExecutorService 是 ExecutorService 的子接口，扩展了任务调度的功能。使用 ExecutorService，我们可以执行提交的任务，而使用 ScheduledExecutorService，我们可以安排任务在将来的某个时间点执行，或者以固定的延迟周期性地执行。

希望本文能够帮助您理解 ScheduledExecutorService 和 ExecutorService 的区别，并在实际开发中选择适合的接口来管理和执行任务。

---