面试题：如何自定义Java线程池停止策略以满足特定业务需求？

设计思路

继承 ThreadPoolExecutor 类：通过继承 ThreadPoolExecutor 类，我们可以获得线程池的所有功能，并能够覆盖其方法来自定义行为。
覆盖停止相关方法：通常需要覆盖 shutdown() 和 shutdownNow() 方法，以实现自定义的停止逻辑。
任务优先级处理：为了按照任务优先级顺序停止任务，可以在任务类中定义优先级字段，并在 shutdown() 方法中实现按优先级排序并停止任务的逻辑。
特定类型任务等待：在 shutdown() 方法中，遍历任务队列，判断任务类型，等待特定类型任务执行完成。

关键代码片段

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

// 自定义任务类，包含优先级
class PrioritizedTask implements Runnable {
    private final int priority;
    private final Runnable task;

    public PrioritizedTask(int priority, Runnable task) {
        this.priority = priority;
        this.task = task;
    }

    public int getPriority() {
        return priority;
    }

    @Override
    public void run() {
        task.run();
    }
}

// 自定义线程池类
class CustomThreadPoolExecutor extends ThreadPoolExecutor {

    public CustomThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
                                    BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

    @Override
    public void shutdown() {
        // 按优先级停止任务
        List<Runnable> tasks = new ArrayList<>(getQueue());
        tasks.sort((t1, t2) -> {
            if (t1 instanceof PrioritizedTask && t2 instanceof PrioritizedTask) {
                return Integer.compare(((PrioritizedTask) t1).getPriority(), ((PrioritizedTask) t2).getPriority());
            }
            return 0;
        });

        for (Runnable task : tasks) {
            if (task instanceof PrioritizedTask) {
                // 处理任务，这里可以是移除任务或等待任务完成等操作
                System.out.println("Handling task with priority: " + ((PrioritizedTask) task).getPriority());
            }
        }

        // 等待特定类型任务执行完成
        for (Runnable task : getQueue()) {
            if (task instanceof SpecificTypeTask) {
                try {
                    // 等待任务完成
                    while (isTaskInProgress((SpecificTypeTask) task)) {
                        Thread.sleep(100);
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }

        super.shutdown();
    }

    @Override
    public List<Runnable> shutdownNow() {
        // 自定义shutdownNow逻辑，例如先尝试按优先级停止部分任务
        List<Runnable> notStartedTasks = new ArrayList<>();
        for (Runnable task : getQueue()) {
            if (task instanceof PrioritizedTask) {
                if (((PrioritizedTask) task).getPriority() < 5) {
                    notStartedTasks.add(task);
                }
            }
        }
        getQueue().removeAll(notStartedTasks);
        return super.shutdownNow();
    }

    // 判断特定类型任务是否正在执行
    private boolean isTaskInProgress(SpecificTypeTask task) {
        // 这里需要根据实际情况实现判断逻辑，例如通过记录任务执行状态等
        return false;
    }
}

// 特定类型任务类
class SpecificTypeTask implements Runnable {
    @Override
    public void run() {
        // 具体任务逻辑
    }
}

在上述代码中：

PrioritizedTask 类为任务添加了优先级。
CustomThreadPoolExecutor 类继承自 ThreadPoolExecutor，覆盖了 shutdown() 和 shutdownNow() 方法，实现了按优先级停止任务以及等待特定类型任务执行完成的逻辑。
isTaskInProgress 方法用于判断特定类型任务是否正在执行，实际应用中需要根据具体情况实现。

星途面试题库

面试题：如何自定义Java线程池停止策略以满足特定业务需求？

知识考点

面试题答案

设计思路

关键代码片段