5 并发编程之Executor框架

在上一篇中，我们讨论了线程与进程的区别，了解了它们的基本概念以及在并发编程中的角色。接下来，我们将深入探讨Java中的Executor框架，这是一个用于处理并发任务的重要工具。Executor框架能够帮助我们更高效地创建和管理线程，从而提升我们应用程序的性能和可维护性。

Executor框架概述

Executor框架是Java 5引入的，主要目的是为了简化线程的管理和执行。它提供了一种更高层次的抽象，允许程序员以更简单的方式执行任务，而不必直接管理线程的生命周期。

核心组件

Executor框架的核心组件主要包括以下几个接口和类：

1. Executor：最基本的执行器接口，用于执行提交的任务。

   public interface Executor {
       void execute(Runnable command);
   }

2. ExecutorService：Executor的一个子接口，提供了更多的方法来管理和控制任务的执行，包括提交任务和关闭服务等。

   public interface ExecutorService extends Executor {
       <T> Future<T> submit(Callable<T> task);
       void shutdown();
       List<Runnable> shutdownNow();
   }

3. ThreadPoolExecutor：ExecutorService的一个实现，支持池化的线程执行器，允许重用线程以减少开销。

4. ScheduledExecutorService：用于支持定时和周期性任务的执行。

创建和使用Executor

使用Executor框架，我们可以轻松创建一个线程池来执行多个并发任务。这里是一个创建和使用ThreadPoolExecutor的简单例子。

示例代码

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

public class ExecutorExample {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        // 提交多个任务
        for (int i = 0; i < 5; i++) {
            final int taskId = i;
            executorService.submit(() -> {
                System.out.println("Executing task " + taskId + " in thread " + Thread.currentThread().getName());
            });
        }

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

在这个例子中，我们创建了一个固定大小为3的线程池，并提交了5个任务。这些任务将会被线程池中的线程并发执行。由于线程池的大小限制，最多只能有3个任务同时执行。

线程池的好处

使用Executor框架和线程池有以下几个显著的好处：

1. 资源管理：通过限制线程的数量，避免了系统因过多线程启动而造成的资源竞争和上下文切换的开销。

2. 任务复用：线程池中的线程可以被复用，减少了创建和销毁线程的开销。

3. 易于控制：使用ExecutorService可以更方便地控制线程的执行，例如优雅地关闭线程。

任务的提交

在ExecutorService中，可以通过多种方式提交任务：

1. 使用Runnable提交任务：

   executorService.execute(new RunnableTask());

2. 使用Callable提交任务（可以返回结果）：

   Future<String> future = executorService.submit(new CallableTask());

示例代码 - Callable

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

public class CallableExample {
    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        
        Callable<String> callableTask = () -> {
            // 模拟耗时操作
            Thread.sleep(2000);
            return "Task completed";
        };
        
        Future<String> future = executorService.submit(callableTask);
        
        // 这里可以做其他事情

        // 获取任务的结果
        String result = future.get(); // 阻塞直到任务完成
        System.out.println(result);

        executorService.shutdown();
    }
}

在上面的例子中，我们使用Callable接口定义了一个可以返回结果的任务。当调用future.get()方法时，如果任务尚未完成，它将阻塞当前线程，直到结果准备好。

小结

通过本文的讨论，我们对Executor框架有了更深入的理解，了解了如何使用线程池来管理并发任务。这种方法不仅增强了代码的可读性和可维护性，还提高了应用程序的性能。在下一篇中，我们将探讨并发集合类，进一步提高我们在并发编程中的技能。

通过合理使用Executor框架，我们可以开发出更高效、更可靠的并发应用。