ExecutorService如何实现任务优先级排序

在Java中，ExecutorService本身并不支持任务优先级排序。但是，你可以使用PriorityBlockingQueue和自定义的ThreadFactory来实现任务优先级排序。

以下是一个简单的示例，展示了如何使用PriorityBlockingQueue和自定义的ThreadFactory实现任务优先级排序：

1. 首先，创建一个实现了Runnable接口的任务类，并添加一个优先级字段：

public class PriorityTask implements Runnable, Comparable<PriorityTask> {
    private int priority;
    private Runnable task;

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

    public int getPriority() {
        return priority;
    }

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

    @Override
    public int compareTo(PriorityTask other) {
        return Integer.compare(other.getPriority(), this.getPriority());
    }
}

2. 创建一个自定义的ThreadFactory，用于创建具有优先级队列的ThreadPoolExecutor：

import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.PriorityBlockingQueue;

public class PriorityThreadFactory implements ThreadFactory {
    private final ThreadFactory defaultThreadFactory = Executors.defaultThreadFactory();
    private final PriorityBlockingQueue<Runnable> priorityQueue = new PriorityBlockingQueue<>();

    @Override
    public Thread newThread(Runnable r) {
        Thread thread = defaultThreadFactory.newThread(() -> {
            while (true) {
                try {
                    Runnable task = priorityQueue.take();
                    task.run();
                } catch (InterruptedException e) {
                    break;
                }
            }
        });
        thread.setDaemon(true);
        return thread;
    }

    public void submit(Runnable task, int priority) {
        priorityQueue.put(new PriorityTask(priority, task));
    }
}

3. 使用自定义的PriorityThreadFactory创建一个ExecutorService：

public class PriorityExecutorService {
    private final PriorityThreadFactory priorityThreadFactory;

    public PriorityExecutorService() {
        priorityThreadFactory = new PriorityThreadFactory();
    }

    public void submit(Runnable task, int priority) {
        priorityThreadFactory.submit(task, priority);
    }

    public void shutdown() {
        priorityThreadFactory.shutdown();
    }
}

现在，你可以使用PriorityExecutorService来提交具有优先级的任务：

public class Main {
    public static void main(String[] args) {
        PriorityExecutorService executorService = new PriorityExecutorService();

        executorService.submit(() -> System.out.println("Task 1 (Priority 5)"), 5);
        executorService.submit(() -> System.out.println("Task 2 (Priority 1)"), 1);
        executorService.submit(() -> System.out.println("Task 3 (Priority 3)"), 3);

        executorService.shutdown();
    }
}

这个示例中，任务将按照优先级从高到低的顺序执行。请注意，这个实现仅用于演示目的，实际应用中可能需要根据具体需求进行调整。