ThreadPoolExecutor的PriorityBlockingQueue支持问题

2019独角兽企业重金招聘Python工程师标准>>>

最近在使用ThreadPoolExecutor时遇到一个问题：当ThreadPoolExecutor使用的BlockingQueue为PriorityBlockingQueue时，会出现异常，原因是java.util.concurrent.FutureTask cannot be cast to java.lang.Comparable。Google之，发现有很多同样的问题，但没有给出解决方案，只能查看源代码以期能找到并解决问题。

首先根据Exception找到问题原因：

Exception in thread "main" java.lang.ClassCastException: java.util.concurrent.FutureTask cannot be cast to java.lang.Comparable
	at java.util.concurrent.PriorityBlockingQueue.siftUpComparable(PriorityBlockingQueue.java:347)
	at java.util.concurrent.PriorityBlockingQueue.offer(PriorityBlockingQueue.java:475)
	at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1329)
	at java.util.concurrent.AbstractExecutorService.submit(AbstractExecutorService.java:132)
...

找到java.util.concurrent.PriorityBlockingQueue.siftUpComparable方法：

private static <T> void siftUpComparable(int k, T x, Object[] array) {
        Comparable<? super T> key = (Comparable<? super T>) x;
        while (k > 0) {
            int parent = (k - 1) >>> 1;
            Object e = array[parent];
            if (key.compareTo((T) e) >= 0)
                break;
            array[k] = e;
            k = parent;
        }
        array[k] = key;
    }

是在Comparable<? super T> key = (Comparable<? super T>) x;上出现问题，根据java.util.concurrent.FutureTask cannot be cast to java.lang.Comparable知道x的类型是java.util.concurrent.FutureTask。现在看看FutureTask：

public class FutureTask<V> implements RunnableFuture<V> {
...

public interface RunnableFuture<V> extends Runnable, Future<V> {
...

public
interface Runnable {
...

public interface Future<V> {
...

可见FutureTask的确没有实现Comparable接口。但是我所提交的Task

public static class Task implements Callable<Integer>, Comparable<Task> {
...

是实现了Comparable接口的。我的Task为什么变成了FutureTask？只好找到ThreadPoolExecutor的submit(Callable<T> task)方法一看究竟，它是在AbstractExecutorService中实现的。

public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }

可以看到通过newTaskFor方法，我所提交的Task变成了FutureTask：

protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new FutureTask<T>(callable);
    }

OK，看来问题就是出在FutureTask这个类上了：

public class FutureTask<V> implements RunnableFuture<V> {
    private final Sync sync;

    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        sync = new Sync(callable);
    }
...
    private final class Sync extends AbstractQueuedSynchronizer {
        private final Callable<V> callable;

        Sync(Callable<V> callable) {
            this.callable = callable;
        }
...

看来他是将我提交的Task的Comparable接口直接忽略了。现在的问题就变成了让FutureTask支持Comparable接口，最简单的方法是用一个ComparableFutureTask继承FutureTask并实现Comparable接口，但也必须要Override ThreadPoolExecutor的newTaskFor方法，显得有些麻烦。为此又继续Google，却没有发现一些更好的方法。先实现了再说。

package canghailan.util.concurrent;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.RunnableFuture;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author canghailan
 * @datetime 2011-12-10 13:57:19
 */
public class XThreadPoolExecutor extends ThreadPoolExecutor {

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

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

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

    public XThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
            long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue,
            ThreadFactory threadFactory, RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
    }

    @Override
    protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new ComparableFutureTask<>(runnable, value);
    }

    @Override
    protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new ComparableFutureTask<>(callable);
    }

    protected class ComparableFutureTask<V>
            extends FutureTask<V> implements Comparable<ComparableFutureTask<V>> {
        private Object object;

        public ComparableFutureTask(Callable<V> callable) {
            super(callable);
            object = callable;
        }

        public ComparableFutureTask(Runnable runnable, V result) {
            super(runnable, result);
            object = runnable;
        }

        @Override
        @SuppressWarnings("unchecked")
        public int compareTo(ComparableFutureTask<V> o) {
            if (this == o) {
                return 0;
            }
            if (o == null) {
                return -1; // high priority
            }
            if (object != null && o.object != null) {
                if (object.getClass().equals(o.object.getClass())) {
                    if (object instanceof Comparable) {
                        return ((Comparable) object).compareTo(o.object);
                    }
                }
            }
            return 0;
        }
    }
}

测试一下：

package canghailan;

import canghailan.util.concurrent.XThreadPoolExecutor;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Phaser;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * @author canghailan
 * @datetime 2011-12-10 7:09:39
 */
public class TestXThreadPoolExecutor {

    public static void main(String args[]) throws Exception {
        Phaser phaser = new Phaser(1);
        ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<>();
        ExecutorService service = new XThreadPoolExecutor(
                5, 5, 0L, TimeUnit.MILLISECONDS, new PriorityBlockingQueue<Runnable>());
        for (int i = 0; i < 10; ++i) {
            phaser.register();
            service.submit(new Task(i, queue, phaser));
        }
        phaser.arriveAndAwaitAdvance();
        System.out.println(queue);
        service.shutdown();
    }

    public static class Task implements Callable<Integer>, Comparable<Task> {
        private Integer id;
        private ConcurrentLinkedQueue<Integer> queue;
        private Phaser phaser;

        public Task(Integer id, ConcurrentLinkedQueue<Integer> queue, Phaser phaser) {
            this.id = id;
            this.queue = queue;
            this.phaser = phaser;
        }

        @Override
        public Integer call() throws Exception {
            queue.offer(id);
            phaser.arrive();
            return id;
        }

        @Override
        public int compareTo(Task o) {
            return -id.compareTo(o.id);
        }
    }
}

输出为[0, 1, 2, 3, 9, 8, 7, 6, 5, 4]，[0, 1, 2, 3, 4, 7, 6, 5, 9, 8]，[0, 1, 2, 3, 4, 7, 6, 5, 9, 8]...。

根据结果来看，的确起作用了。先到此为止，如果有更好的办法，请不吝赐教。

转载于:https://my.oschina.net/canghailan/blog/37006