具有Set属性的Queue

前言

---

在最近的工作中，遇到了一个特殊的需求：我们需要一个队列来存放某数据对象，但是这个对象的数量是巨大的，如果将这些对象都存入队列的话，很显然内存会爆表，但是这些对象有一个特征是，相同的数据对象类型的数据是可更新的。换句话说，对于同一类数据对象，后面来的对象的值一定比前面的新，是可以完全覆盖前面的。所以如果对象是可更新的，我们可以通过重写对象的hashcode和equals方法，然后放在Set集合中进行保存。但是我们还需要此数据结构能保存队列的FIFO特性，这时候该怎么办呢？所以在这里，我们需要能够自定义一个具有Set属性的Queue。

去重队列：UniqueQueue

---

在讲述具有Set属性的Queue之前，我们先来看一个初级版本的SetQueue：具有去重属性的队列（此处不需要更新对象，当队列中添加了相同对象的时候）。

要想实现这个功能需求的Queue,过程并不复杂，我们只需额外Queue做一层包装，添加额外的Set对象来记录当前已添加的对象，然后利用此Set做去重判断。

此Queue的类变量定义如下：

/**
 * Thread unsafe implementation of UniqueQueue.
 */
public class UniqueQueue<T> implements Queue<T> {
    private final Queue<T> queue = new LinkedList<T>();
    /** Set集合用来去重 **/
    private final Set<T> set = new HashSet<T>();
    private ReentrantLock lock = new ReentrantLock();
    ...

在Queue的实现接口中，我们可以先只实现offer、poll方法，对应的操作就是加入、取出操作。

offer方法实现代码如下：

    @Override
    public boolean offer(T t) {
        // 首先进行锁定操作
        lock.lock();
        try {
            // 直接调用Set的add方法，如果当前集合已经存在此对象，则方法会返回失败
            if (set.add(t)) {
                // 否则将对象加入到队列中
                queue.add(t);
                return true;
            } else {                
                return false;
            }
        } finally {
            // 进行锁释放操作
            lock.unlock();
        }
    }

poll方法实现代码如下：

    @Override
    public T poll() {
        lock.lock();
        try {
            // 从队列首部取出对象
            T t = queue.poll();
            // 如果对象不为空，则从Set集合中相应的移出
            if (t != null) {
                set.remove(t);
            }
            return t;
        } finally {
            lock.unlock();
        }
    }

通过以上的实现，我们就实现了一个带有去重属性的Queue。大家可以自行对此Queue进行测试，自定义的添加对象是需要重载比较方法的，否则会被认为是不同对象，这一点需要注意。UniqueQueue的全部实现代码在文章末尾链接中将会给出。

去重可更新队列：UpdatedQueue

---

基于上部分UniqueQueue，下面我们来看对此的一个扩展：Queue不仅仅需要是去重的，而且它需要是可更新的。这个需求在很多应用场景中会碰到，比如说实时展示商品销售信息。按照往常的做法，我们的做法是定期的获取商品销售信息并进行展示，但是如果说商品信息的量在非常大的情况下时，怎么办，如果一次性没法更新完毕，下一周期的数据又来了，这又会增加新的压力。在这种情况下，可更新队列可以巧妙地帮我们解决这个问题。

首先是此队列结构的定义：

/**
 * The queue is unique and meanwhile can be updated
 */
public class UpdatedQueue <K, T> implements Queue<T> {
    protected final Queue<T> queue = new LinkedList<T>();
    // HashMap此处用来做重复对象的查找与更新
    protected final HashMap<K, T> map = new HashMap<K, T>();
    // 用ReentrantLock实现线程安全
    protected ReentrantLock lock = new ReentrantLock();

    @Override
    public int size() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return queue.size();
        } finally {
            lock.unlock();
        }
    }

    @Override
    public boolean isEmpty() {
        boolean isEmpty = false;

        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            isEmpty = queue.isEmpty();
        } finally {
            lock.unlock();
        }

        return isEmpty;
    }
    ...
}

上述类只是一个基础类，去重队列的核心操作我们可以实现在子类实现中，后面大家可以再进一步地对此进行抽象化。我新建了一个BallUpdatedQueue的实现子类，以及相应的实体类Ball。

Ball对象代表的意思是一个球，它具有如下属性，其中球类名称作为唯一区别符：

public class Ball {
    // 球类的名称
    String ballName;
    // 球的单价
    int price;
    // 球的销售量
    int numSale;

    public Ball(String ballName, int price, int numSale) {
        this.ballName = ballName;
        this.price = price;
        this.numSale = numSale;
    }

    /**
     * 球信息更新操作
     * @param newBall
     */
    public void valueUpdated(Ball newBall) {
        this.price = newBall.price;
        this.numSale = newBall.numSale;
    }

    public String getUniqueKey() {
        return this.ballName;
    }

    @Override
    public String toString() {
        return "Ball [ballName=" + ballName + ", price=" + price + ", numSale=" + numSale + "]";
    }
}

然后是可更新队列的实现：

public class BallUpdatedQueue extends UpdatedQueue<String, Ball> {
    @Override
    public boolean offer(Ball newBall) {
        Ball ball = null;
        // 获取对象的唯一键值
        String uniqueKey = newBall.getUniqueKey();

        lock.lock();
        try {
            // 如果当前图中已经包含此键值，表明队列中已有同属性对象
            if (map.containsKey(uniqueKey)) {
                // 取出此键值对应的对象，进行属性值的更新，因为map中的对象与queue中的对象是同一引用，所以能达到更新的效果
                ball = map.get(uniqueKey);
                ball.valueUpdated(newBall);
            } else {
                map.put(uniqueKey, newBall);
                queue.offer(newBall);
            }
        } finally {
            lock.unlock();
        }

        return true;
    }

    @Override
    public Ball poll() {
        Ball ball = null;
        String uniqueKey;

        lock.lock();
        try {
            // 取出队列头部对象
            ball = queue.poll();

            if (ball != null) {
                // 取出对象的唯一键值
                uniqueKey = ball.getUniqueKey();
                // 从图中也同样移除
                map.remove(uniqueKey);
            }
        } finally {
            lock.unlock();
        }

        return ball;
    }
}

在上述代码中已经进行了详细的注释，这里就不进行过多的解释了，这里的一个核心点在于利用了HashMap进行去重更新的处理。

下面是相应的测试方法：

public class TestUpdatedQueue {
    public static void main(String[] args){
        Ball footBall = new Ball("football", 10, 0);
        Ball basketBall = new Ball("basketball", 20, 0);
        Ball baseBall = new Ball("baseball", 15, 0);

        BallUpdatedQueue ballInfoQueue = new BallUpdatedQueue();
        ballInfoQueue.offer(footBall);
        ballInfoQueue.offer(basketBall);
        ballInfoQueue.offer(baseBall);

        // 这里的球总数应该是3个
        System.out.println("The total ball number: " + ballInfoQueue.size());

        // 调整足球的价格和销售数量，然后加入到队列中
        footBall = new Ball("football", 30, 10);
        ballInfoQueue.offer(footBall);
        // 队列中的球的数量应该还是3个
        System.out.println("The total ball number: " + ballInfoQueue.size());

        // 取出当前队列头部的对象，即足球对象，输出此球对象的信息，信息已被更新
        Ball ball = ballInfoQueue.poll();
        System.out.println(ball);
    }
}

本地测试输出的结果如下：

The total ball number: 3
The total ball number: 3
Ball [ballName=football, price=30, numSale=10]

代码链接

---

[1].https://github.com/linyiqun/SetQueues