Java并发类API--Executor与ThreadPoolExecutor

在 Java 中，Executor 和 ThreadPoolExecutor 是用于管理线程和执行任务的工具，帮助开发者更好地控制多线程环境。下面是它们的使用和区别。

1.Executor 简介

Executor 是一个接口，用来创建线程池，它定义了一个 execute(Runnable command) 方法，用于执行传递进来的任务。它是 Java 中线程池的基础。

但Executor是接口，并不能直接使用，所以还得需要实现类，图4-3中所示的内容就是完整的Executor接口相关的类继承结构。

对于简单的线程管理，使用 Executor 接口或 Executors 工具类创建的线程池通常足够。这些工具提供了一些便捷的方法来创建常见类型的线程池，如固定大小的线程池、单线程执行器和缓存线程池。以下是几个常见的例子：

1.)使用 Executors.newFixedThreadPool(int nThreads)

创建一个固定大小的线程池，适用于需要固定数量线程执行任务的场景。

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

public class FixedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3); // 创建一个包含3个线程的固定线程池

        for (int i = 0; i < 10; i++) {
            executor.execute(new Task(i));
        }

        executor.shutdown(); // 关闭线程池，等待所有任务完成
    }
}

class Task implements Runnable {
    private int taskId;

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

    @Override
    public void run() {
        System.out.println("执行任务 " + taskId + " 在线程 " + Thread.currentThread().getName());
    }
}

2) 使用 Executors.newSingleThreadExecutor()

创建一个单线程执行器，适用于需要按顺序执行任务的场景。

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

public class SingleThreadExecutorExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor(); // 创建一个单线程执行器

        for (int i = 0; i < 5; i++) {
            executor.execute(new Task(i));
        }

        executor.shutdown(); // 关闭执行器，等待所有任务完成
    }
}

class Task implements Runnable {
    private int taskId;

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

    @Override
    public void run() {
        System.out.println("执行任务 " + taskId + " 在线程 " + Thread.currentThread().getName());
    }
}

3.)使用 Executors.newCachedThreadPool()

创建一个缓存线程池，适用于短时间内需要大量并发、但不确定具体线程数量的场景。线程池会根据需要动态创建新线程，空闲线程超过60秒会被回收。

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

public class CachedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool(); // 创建一个缓存线程池

        for (int i = 0; i < 10; i++) {
            executor.execute(new Task(i));
        }

        executor.shutdown(); // 关闭线程池，等待所有任务完成
    }
}

class Task implements Runnable {
    private int taskId;

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

    @Override
    public void run() {
        System.out.println("执行任务 " + taskId + " 在线程 " + Thread.currentThread().getName());
    }
}

4) 使用 Executors.newScheduledThreadPool(int corePoolSize)

创建一个调度线程池，适用于需要周期性执行任务的场景。比如在固定的延迟后重复执行任务。

import java.util.concurrent.*;

public class ScheduledThreadPoolExample {
    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(2); // 创建一个调度线程池

        executor.scheduleAtFixedRate(new Task(1), 0, 2, TimeUnit.SECONDS); // 每2秒执行一次任务

        // executor.shutdown(); // 通常不需要立即关闭调度线程池，除非你确认所有任务已经完成
    }
}

class Task implements Runnable {
    private int taskId;

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

    @Override
    public void run() {
        System.out.println("执行任务 " + taskId + " 在线程 " + Thread.currentThread().getName());
    }
}

总结

• newFixedThreadPool：适合需要固定数量线程来执行大量并发任务的场景。

• newSingleThreadExecutor：适合任务必须顺序执行的场景。

• newCachedThreadPool：适合任务数量波动大且需要高并发的场景。

• newScheduledThreadPool：适合需要定时或周期性执行任务的场景。

这些工具类的简化了线程池的创建和管理，对于简单的线程管理场景，这些方法足够使用。

2. ThreadPoolExecutor 简介

ThreadPoolExecutor 是 Executor 接口的实现类，是 Java 中最灵活和可配置的线程池实现。它提供了丰富的配置选项，允许开发者自定义线程池的行为。

类ThreadPoolExecutor的方法列表:

构造函数：

ThreadPoolExecutor 的构造函数允许你设置以下参数：

• corePoolSize: 核心线程数，当任务数量少于这个数目时，即使有空闲线程也不会被回收。

• maximumPoolSize: 最大线程数，表示线程池中允许存在的最大线程数。

• keepAliveTime: 当线程数量超过核心线程数时，多余空闲线程的存活时间。

• unit: keepAliveTime 的时间单位。

• workQueue: 用于保存等待执行任务的队列。

• threadFactory: 用于创建新线程的工厂。

• handler: 当任务无法被执行时的处理器。

使用示例：

import java.util.concurrent.*;

public class ThreadPoolExecutorExample {
    public static void main(String[] args) {
        int corePoolSize = 2;
        int maximumPoolSize = 4;
        long keepAliveTime = 10;
        TimeUnit unit = TimeUnit.SECONDS;
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(2);

        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            corePoolSize,
            maximumPoolSize,
            keepAliveTime,
            unit,
            workQueue,
            new ThreadPoolExecutor.CallerRunsPolicy() // 当线程池满时的策略
        );

        for (int i = 0; i < 10; i++) {
            executor.execute(new Task(i));
        }

        executor.shutdown();
    }
}

class Task implements Runnable {
    private int taskId;

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

    @Override
    public void run() {
        System.out.println("执行任务 " + taskId + " 在线程 " + Thread.currentThread().getName());
        try {
            Thread.sleep(2000); // 模拟任务执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

解释

1. 创建 ThreadPoolExecutor：

• 我们创建了一个线程池，核心线程数为2，最大线程数为4，使用一个容量为2的阻塞队列来保存任务。

• 当线程池中线程数超过 corePoolSize 时，空闲线程会在 keepAliveTime 时间内存活。

2. 提交任务：

• 向线程池提交了10个任务。根据配置，最开始会创建2个核心线程，处理任务。接着会放入阻塞队列中，当队列满了之后，会创建新线程处理任务，直到达到 maximumPoolSize。如果线程池和队列都满了，则会执行指定的拒绝策略。

3. 拒绝策略：

• 这里使用 CallerRunsPolicy，当线程池和队列都满时，任务会在调用 execute 的线程中执行。

4. 关闭线程池：

• 使用 shutdown() 方法来关闭线程池，确保所有已提交的任务都会执行完毕。

总结

• Executor: 是一个更简单的接口，用于任务的执行，但提供的功能有限。

• ThreadPoolExecutor: 是一个更高级的实现，允许对线程池的大小、任务队列、线程超时、线程创建工厂等进行更详细的控制，适合需要高度自定义线程池行为的场景。

对于简单的线程管理，Executor 或使用 Executors 工具类创建的线程池足够了。但如果你需要更复杂的线程池管理，ThreadPoolExecutor 是一个强大的工具。