PriorityQueue和Queue的一种变体的实现

队列和优先队列是我们十分熟悉的数据结构。提供了所谓的“先进先出”功能，优先队列则按照某种规则“先进先出”。但是他们都没有提供：“固定大小的队列”和“固定大小的优先队列”的功能。

比如我们要实现：记录按照时间排序的最近的登录网站的20个人；按照分数排序的最高的30个人；比如在游戏中一场两两PK的战斗，得分最高的6个人；要实现这些功能时，需要的数据结构，在java类库中没有现成的类。我们需要利用现有的类库来实现它们。

1. 固定大小的“先进先出”队列

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.LinkedBlockingQueue;

public class TopQueue<E> {
    private final LinkedBlockingQueue<E> blockQueue;

    public TopQueue(int size){
        this.blockQueue = new LinkedBlockingQueue<E>(size);
    }

    public synchronized void put(E e) throws InterruptedException{
        if(blockQueue.offer(e)){
            return;
        }else{
            blockQueue.take();
            blockQueue.offer(e);
        }
    }

    public List<E> getAll(){
        return new ArrayList<E>(blockQueue);
    }

    public static void main(String[] args) throws InterruptedException{
        TopQueue<Integer> tq = new TopQueue<Integer>(3);
        tq.put(1);
        tq.put(2);
        tq.put(3);
        System.out.println(Arrays.toString(tq.getAll().toArray()));

        tq.put(4);
        System.out.println(Arrays.toString(tq.getAll().toArray()));

        tq.put(5);
        System.out.println(Arrays.toString(tq.getAll().toArray()));

        tq.put(6);
        System.out.println(Arrays.toString(tq.getAll().toArray()));
    }
}

输出的结果为：

[1, 2, 3]
[2, 3, 4]
[3, 4, 5]
[4, 5, 6]

上面的TopQueue实现了“固定大小的线程安全的”队列。无论有多少个线程，向TopQueue中放入了多少个元素，在TopQueue中只保留最后放进去的n个元素。

2. 固定大小的优先队列（实现一）

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.PriorityBlockingQueue;
import com.alibaba.fastjson.JSON;

public class TopPriorityQueue<E> {
    private final PriorityBlockingQueue<E> blockQueue;
    private final int size;

    public TopPriorityQueue(int size){
        this.blockQueue = new PriorityBlockingQueue<E>(size + 1);
        this.size = size + 1;    // 这里多加1的原因是防止put方法中将大的删除了，反而降小的插入了，所以多加1个用做"哨卡"
    }

    public synchronized void put(E e) throws InterruptedException{
        if(blockQueue.size() >= size)
            blockQueue.take();
        blockQueue.offer(e);
    }

    public List<E> getAll() throws InterruptedException{
        synchronized(this){
            if(blockQueue.size() >= size)
                blockQueue.take();    // 前面构造函数中多加了1，这里减掉一个
        }
        return new ArrayList<E>(blockQueue);
    }

    public static void main(String[] args) throws InterruptedException{
        final TopPriorityQueue<User> tq = new TopPriorityQueue<User>(3);
        User u1 = new User(1, "bbb", 10);
        User u2 = new User(2, "ccc", 20);
        User u3 = new User(3, "ddd", 30);
        User u4 = new User(4, "fff", 40);
        User u5 = new User(5, "fff", 50);
        User u6 = new User(6, "ddd", 60);
        User u7 = new User(7, "ggg", 70);
        User u8 = new User(8, "hhh", 80);

        tq.put(u4);    //
        System.out.println(JSON.toJSONString(tq.getAll()));
        tq.put(u8);    //4,8
        System.out.println(JSON.toJSONString(tq.getAll()));
        tq.put(u7);    //4,8,7
        System.out.println(JSON.toJSONString(tq.getAll()));
        tq.put(u5);    //5,8,7
        System.out.println(JSON.toJSONString(tq.getAll()));
        tq.put(u2);    //5,8,7
        System.out.println(JSON.toJSONString(tq.getAll()));
        tq.put(u3);    //5,8,7
        System.out.println(JSON.toJSONString(tq.getAll()));
        tq.put(u1);    //5,8,7
        System.out.println(JSON.toJSONString(tq.getAll()));
        tq.put(u6);    //6,8,7
        System.out.println(JSON.toJSONString(tq.getAll()));
    }
}

User类：

import java.util.Comparator;

public class User implements Comparable<User>{
    private int id;
    private String name;
    private long score;    // 得分
    // ... ...

    public User(int id, String name, long score){
        this.id = id;
        this.name = name;
        this.score = score;
    }

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public long getScore() {
        return score;
    }
    public void setScore(long score) {
        this.score = score;
    }

    @Override
    public int compareTo(User o) {
        return this.getScore() > o.getScore() ? 1 : this.getScore() < o.getScore() ? -1 : 0;
    }
}

输入的结果为：

[{"id":4,"name":"fff","score":40}]
[{"id":4,"name":"fff","score":40},{"id":8,"name":"hhh","score":80}]
[{"id":4,"name":"fff","score":40},{"id":8,"name":"hhh","score":80},{"id":7,"name":"ggg","score":70}]
[{"id":5,"name":"fff","score":50},{"id":8,"name":"hhh","score":80},{"id":7,"name":"ggg","score":70}]
[{"id":5,"name":"fff","score":50},{"id":8,"name":"hhh","score":80},{"id":7,"name":"ggg","score":70}]
[{"id":5,"name":"fff","score":50},{"id":8,"name":"hhh","score":80},{"id":7,"name":"ggg","score":70}]
[{"id":5,"name":"fff","score":50},{"id":8,"name":"hhh","score":80},{"id":7,"name":"ggg","score":70}]
[{"id":6,"name":"ddd","score":60},{"id":8,"name":"hhh","score":80},{"id":7,"name":"ggg","score":70}]

TopPriorityQueue实现了“固定大小的优先队列”，的实现原理是：

public synchronized void put(E e) throws InterruptedException{
        if(blockQueue.size() >= size)
            blockQueue.take();
        blockQueue.offer(e);
 }

当队列满了，还要插入时，就删除队列中最小的一个，然后再插入。但是这里涉及到一个问题，如果这个要被插入的元素优先级要比那个被删除的元素优先级低呢？那岂不是将大的删除了，反而将小的插入了。所以这里我们采取的办法是，比实际要求的size的基础上多保留一个，用做“哨卡”。当队列满了时，我们将“哨卡”删掉，然后再插入我们的元素，然后队列中新的最小的元素就成为了新的“哨卡”。而“哨卡”因为是最小的一个，不是我们需要的，返回最终结果时会被删除掉。所以不会出现删除了大的，插入了小的问题。这里有点小技巧。

3. 固定大小的优先队列（实现二）

上面的实现，需要我们插入队列的元素Comparable这个接口，但是实际环境中，我们不太可能去进行这样的修改，所以我们还有另外一种方法——使用Comparator来搞定，看代码：

import java.util.Comparator;
import com.coin.User;

public class MyComparator implements Comparator<User> {
    @Override
    public int compare(User u1, User u2) {
        if(u1.getScore() > u2.getScore())
            return 1;
        if(u1.getScore() < u2.getScore())
            return -1;
        return 0;
    }
}

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.PriorityBlockingQueue;

import com.alibaba.fastjson.JSON;

public class TopPriorityQueue<E> {
    private final PriorityBlockingQueue<E> blockQueue;
    private final int size;

    public TopPriorityQueue(int size, Comparator<E> comparator){
        this.blockQueue = new PriorityBlockingQueue<E>(size + 1, comparator);
        this.size = size + 1;    // 这里多加1的原因是防止put方法中将大的删除了，反而降小的插入了，所以多加1个用做"哨卡"
    }

    public synchronized void put(E e) throws InterruptedException{
        if(blockQueue.size() >= size)
            blockQueue.take();
        blockQueue.offer(e);
    }

    public List<E> getAll() throws InterruptedException{
        synchronized(this){
            if(blockQueue.size() >= size)
                blockQueue.take();    // 前面构造函数中多加了1，这里减掉一个
        }

        return new ArrayList<E>(blockQueue);
    }

    public static void main(String[] args) throws InterruptedException{
        MyComparator myComparator = new MyComparator();
        final TopPriorityQueue<User> tq = new TopPriorityQueue<User>(3, myComparator);
        User u1 = new User(1, "bbb", 10);
        User u2 = new User(2, "ccc", 20);
        User u3 = new User(3, "ddd", 30);
        User u4 = new User(4, "fff", 40);
        User u5 = new User(5, "fff", 50);
        User u6 = new User(6, "ddd", 60);
        User u7 = new User(7, "ggg", 70);
        User u8 = new User(8, "hhh", 80);

        tq.put(u4);    //
        System.out.println(JSON.toJSONString(tq.getAll()));
        tq.put(u8);    //4,8
        System.out.println(JSON.toJSONString(tq.getAll()));
        tq.put(u7);    //4,8,7
        System.out.println(JSON.toJSONString(tq.getAll()));
        tq.put(u5);    //5,8,7
        System.out.println(JSON.toJSONString(tq.getAll()));
        tq.put(u2);    //5,8,7
        System.out.println(JSON.toJSONString(tq.getAll()));
        tq.put(u3);    //5,8,7
        System.out.println(JSON.toJSONString(tq.getAll()));
        tq.put(u1);    //5,8,7
        System.out.println(JSON.toJSONString(tq.getAll()));
        tq.put(u6);    //6,8,7
        System.out.println(JSON.toJSONString(tq.getAll()));
    }
}

所以我们在使用PriorityBlockingQueue时，要么我们插入的元素实现了Comparable这个接口，要么我定义一个Comparator，传入到PriorityBlockingQueue的构造函数中，我们可以看下PriorityBlockingQueue.offer(e)方法的源码，它会对这两种情况进行判断：

public boolean offer(E e) {
        if (e == null)
            throw new NullPointerException();
        final ReentrantLock lock = this.lock;
        lock.lock();
        int n, cap;
        Object[] array;
        while ((n = size) >= (cap = (array = queue).length))
            tryGrow(array, cap);
        try {
            Comparator<? super E> cmp = comparator;
            if (cmp == null)
                siftUpComparable(n, e, array);
            else
                siftUpUsingComparator(n, e, array, cmp);
            size = n + 1;
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
        return true;
    }

其中的代码：

            Comparator<? super E> cmp = comparator;
            if (cmp == null)
                siftUpComparable(n, e, array);
            else
                siftUpUsingComparator(n, e, array, cmp);

就是判断我们是否在PriorityBlockingQueue的构造函数中是否传入了Comparator。这样User类就不需要实现Comparable接口了。

另外我们要注意 LinkedBlockingQueue  和  PriorityBlockingQueue 有一点不同，BlockingQueue.offer(e)在队列满了时，会返回false，而PriorityBlockingQueue.offer()即使队列满了，它会进行扩展，永远只返回true.

LinkedBlockingQueue .offer() 的源码如下：

/**
     * Inserts the specified element at the tail of this queue if it is
     * possible to do so immediately without exceeding the queue's capacity,
     * returning {@code true} upon success and {@code false} if this queue
     * is full.
     * When using a capacity-restricted queue, this method is generally
     * preferable to method {@link BlockingQueue#add add}, which can fail to
     * insert an element only by throwing an exception.
     *
     * @throws NullPointerException if the specified element is null
     */
    public boolean offer(E e) {
        if (e == null) throw new NullPointerException();
        final AtomicInteger count = this.count;
        if (count.get() == capacity)
            return false;
        int c = -1;
        Node<E> node = new Node<E>(e);
        final ReentrantLock putLock = this.putLock;
        putLock.lock();
        try {
            if (count.get() < capacity) {
                enqueue(node);
                c = count.getAndIncrement();
                if (c + 1 < capacity)
                    notFull.signal();
            }
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            signalNotEmpty();
        return c >= 0;
    }

当满了时返回false:

if (count.get() == capacity)
       return false;

PriorityBlockingQueue.offer() 的源码如下：

/**
     * Inserts the specified element into this priority queue.
     * As the queue is unbounded, this method will never return {@code false}.
     *
     * @param e the element to add
     * @return {@code true} (as specified by {@link Queue#offer})
     * @throws ClassCastException if the specified element cannot be compared
     *         with elements currently in the priority queue according to the
     *         priority queue's ordering
     * @throws NullPointerException if the specified element is null
     */
    public boolean offer(E e) {
        if (e == null)
            throw new NullPointerException();
        final ReentrantLock lock = this.lock;
        lock.lock();
        int n, cap;
        Object[] array;
        while ((n = size) >= (cap = (array = queue).length))
            tryGrow(array, cap);
        try {
            Comparator<? super E> cmp = comparator;
            if (cmp == null)
                siftUpComparable(n, e, array);
            else
                siftUpUsingComparator(n, e, array, cmp);
            size = n + 1;
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
        return true;
    }

当满了时，会扩容：

while ((n = size) >= (cap = (array = queue).length))
            tryGrow(array, cap);

As the queue is unbounded, this method will never return {@code false}.

另外TopQueue 和 TopPriorityQueue 都是线程安全的，但是并不保证插入队列中的元素自身的线程安全性。