java threadpoolexecutor如何实现任务优先级

在Java中，ThreadPoolExecutor 本身并不支持任务优先级。但是，你可以通过以下方法实现任务优先级：

使用 PriorityBlockingQueue 作为工作队列：PriorityBlockingQueue 是一个支持优先级的阻塞队列，它可以根据任务的优先级对任务进行排序。你可以创建一个自定义的任务类（实现 Runnable 或 Callable 接口），并在其中定义一个优先级属性。然后，将任务类作为参数传递给 PriorityBlockingQueue 的构造函数。

class PriorityTask<T extends Comparable<T>> implements Runnable, Comparable<PriorityTask<T>> {
    private T priority;
    private Runnable task;

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

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

    @Override
    public int compareTo(PriorityTask<T> other) {
        return other.priority.compareTo(this.priority);
    }
}

创建一个自定义的 ThreadPoolExecutor：继承 ThreadPoolExecutor 类，并重写 newTaskFor 方法。在这个方法中，将任务包装成一个 PriorityTask 对象，并将其提交给 PriorityBlockingQueue。

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

    @Override
    protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        if (callable instanceof PriorityCallable) {
            return new PriorityFutureTask<>((PriorityCallable<T>) callable);
        } else {
            throw new IllegalArgumentException("Callable must implement PriorityCallable");
        }
    }
}

创建一个支持优先级的任务类：实现 PriorityCallable 接口，该接口扩展了 Callable 接口并添加了一个 getPriority() 方法。

class PriorityFutureTask<T> extends FutureTask<T> implements Comparable<PriorityFutureTask<T>> {
    private final int priority;

    public PriorityFutureTask(Callable<T> callable) {
        super(callable);
        if (!(callable instanceof PriorityCallable)) {
            throw new IllegalArgumentException("Callable must implement PriorityCallable");
        }
        this.priority = ((PriorityCallable<T>) callable).getPriority();
    }

    @Override
    public int compareTo(PriorityFutureTask<T> other) {
        return Integer.compare(other.priority, this.priority);
    }
}

使用自定义的 PriorityThreadPoolExecutor 提交任务：

PriorityThreadPoolExecutor executor = new PriorityThreadPoolExecutor(3, 5, 60, TimeUnit.SECONDS, new PriorityBlockingQueue<>());
executor.submit(new PriorityTask<>(1, () -> {
    System.out.println("Task with priority 1 is running");
    return null;
}));
executor.submit(new PriorityTask<>(3, () -> {
    System.out.println("Task with priority 3 is running");
    return null;
}));
executor.shutdown();

这样，PriorityThreadPoolExecutor 将根据任务的优先级对任务进行排序，优先级较高的任务将优先执行。

最新问答

相关标签