使用ThreadPoolExecutor的PriorityBlockingQueue实现优先级队列任务遇到的类型转化问题

把BlockingQueue替换为PriorityBlockingQueue,从而实现对优先级任务处理的线程池，如下代码实现是没有问题的：

public class RunExecuteTask {

    public static void main(String[] args) {

        ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 2, 1, TimeUnit.DAYS, new PriorityBlockingQueue<>());

        try {

            for (int i = 0; i < 5; i++) {

                executor.execute(new RunnablePriority(1));
            }

            Thread.sleep(1000);

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

        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {

            System.out.println(executor.isShutdown());

            executor.shutdown();

            System.out.println(executor.isShutdown());
        }
    }

}

public class RunnablePriority implements Runnable,Comparable<RunnablePriority> {

    private Integer priority;

    public Integer getPriority() {
        return priority;
    }

    public RunnablePriority(Integer priority) {
        this.priority = priority;
    }

    /**
     * 优先级比较
     * @param o
     * @return
     */
    @Override
    public int compareTo(RunnablePriority o) {
        if (this.getPriority() < o.priority){
            return 1;
        }else if (this.getPriority() > o.priority){
            return -1;
        }
        return 0;
    }

    @Override
    public void run() {

        System.out.println("Thread " + Thread.currentThread().getName() + " prioroty " + priority);

        try{

            Thread.sleep(1000);
        }catch (Exception e){
            e.printStackTrace();
        }

        System.out.println("Thread " + Thread.currentThread().getName() + " 开始执行任务 ...");

    }
}

但是runnable 替换为有返回值的callable，则会报:

java.lang.ClassCastException: java.util.concurrent.FutureTask cannot be cast to java.lang.Comparable
    at java.util.concurrent.PriorityBlockingQueue.siftUpComparable(PriorityBlockingQueue.java:357)
    at java.util.concurrent.PriorityBlockingQueue.offer(PriorityBlockingQueue.java:489)
    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1361)
    at java.util.concurrent.AbstractExecutorService.submit(AbstractExecutorService.java:134)

原因是所提交的RunnablePriority转换为了FutureTask，而FutureTask并没有实现Comparable接口，因此将代码改造如下：

public class ComparableFutureTask extends FutureTask implements Comparable<ComparableFutureTask> {

    private Integer priority;

    public Integer getPriority() {
        return priority;
    }

    public ComparableFutureTask(Callable callable,Integer priority) {
        super(callable);
        this.priority = priority;
    }

    @Override
    public int compareTo(ComparableFutureTask task) {
        if (this.getPriority() < task.getPriority()){
            return 1;
        }else if (this.getPriority() > task.getPriority()){
            return -1;
        }
        return 0;
    }

}

public class MyCall implements Callable<Integer> {

    private Integer priority;

    public MyCall(Integer priority) {
        this.priority = priority;
    }

    @Override
    public Integer call() throws Exception {

        System.out.println("Thread " + Thread.currentThread().getName() + " priority " + priority);

        try{

            Thread.sleep(1000);
        }catch (Exception e){
            e.printStackTrace();
        }

        System.out.println("Thread " + Thread.currentThread().getName() + " 开始执行任务 ...");

        return priority;
    }
}

public class ExecuteTask {

    public static void main(String[] args) {

        task();

    }


    private static void task(){

        ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 2, 1, TimeUnit.DAYS, new PriorityBlockingQueue<>());

        List<Future<Integer>> list = new ArrayList<>();

        try {

            for (int i = 0; i < 5; i++) {

                ComparableFutureTask task = new ComparableFutureTask(new MyCall(1),1);
                executor.execute(task);
                Future<Integer> call = task;
                list.add(call);
            }

            Thread.sleep(1000);

            for (int i = 0; i < 5; i++) {

                ComparableFutureTask task = new ComparableFutureTask(new MyCall(5),5);
                executor.execute(task);
                Future<Integer> call = task;
                list.add(call);
            }

        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {

            System.out.println(executor.isShutdown());

            executor.shutdown();

            System.out.println(executor.isShutdown());
        }

        Integer result = 0;

        for (Future<Integer> future : list){

            try {
                result += future.get();
            }catch (Exception e){
                e.printStackTrace();
            }
        }

        System.out.println(result);
    }

}