java Executor执行器任务优先级设置

在Java中，Executor接口本身并不支持任务优先级。但是，你可以使用PriorityBlockingQueue和ThreadPoolExecutor来实现具有优先级的任务执行。

以下是一个简单的示例，展示了如何使用PriorityBlockingQueue和ThreadPoolExecutor实现优先级任务执行：

1. 首先，创建一个实现了Runnable接口的任务类，并实现compareTo方法以定义任务优先级：

import java.util.concurrent.Callable;

public class PriorityTask implements Callable<Void>, Comparable<PriorityTask> {
    private int priority;

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

    @Override
    public Void call() {
        System.out.println("Executing task with priority: " + priority);
        return null;
    }

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

2. 创建一个PriorityBlockingQueue实例，用于存储具有优先级的任务：

import java.util.concurrent.PriorityBlockingQueue;

public class PriorityTaskQueue {
    private PriorityBlockingQueue<PriorityTask> queue;

    public PriorityTaskQueue() {
        queue = new PriorityBlockingQueue<>();
    }

    public void addTask(PriorityTask task) {
        queue.put(task);
    }

    public PriorityTask getTask() throws InterruptedException {
        return queue.take();
    }
}

3. 创建一个ThreadPoolExecutor实例，并使用PriorityTaskQueue作为任务队列：

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

public class PriorityThreadPoolExecutor {
    private ThreadPoolExecutor executor;
    private PriorityTaskQueue taskQueue;

    public PriorityThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit) {
        taskQueue = new PriorityTaskQueue();
        executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, taskQueue);
    }

    public void submitTask(PriorityTask task) {
        executor.submit(task);
    }

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

4. 最后，在主程序中使用PriorityThreadPoolExecutor提交具有不同优先级的任务：

import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) {
        PriorityThreadPoolExecutor executor = new PriorityThreadPoolExecutor(2, 4, 60, TimeUnit.SECONDS);

        executor.submitTask(new PriorityTask(3));
        executor.submitTask(new PriorityTask(1));
        executor.submitTask(new PriorityTask(5));
        executor.submitTask(new PriorityTask(2));

        executor.shutdown();
    }
}

这个示例中，我们创建了一个具有优先级的任务队列，并使用ThreadPoolExecutor执行这些任务。任务类PriorityTask实现了Comparable接口，以便根据优先级对任务进行排序。当我们提交任务时，它们会根据优先级顺序执行。