数据添加异步解析刷新大数据量redis （——）（一）Java Collection之Queue队列

Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Queue接口。Queue接口窄化了对LinkedList的方法的访问权限（即在方法中的参数类型如果是Queue时，就完全只能访问Queue接口所定义的方法了，而不能直接访问 LinkedList的非Queue的方法），以使得只有恰当的方法才可以使用。BlockingQueue 继承了Queue接口。

队列是一种数据结构．它有两个基本操作：在队列尾部加人一个元素，和从队列头部移除一个元素就是说，队列以一种先进先出的方式管理数据，如果你试图向一个已经满了的阻塞队列中添加一个元素或者是从一个空的阻塞队列中移除一个元索，将导致线程阻塞．在多线程进行合作时，阻塞队列是很有用的工具。工作者线程可以定期地把中间结果存到阻塞队列中而其他工作者线线程把中间结果取出并在将来修改它们。队列会自动平衡负载。如果第一个线程集运行得比第二个慢，则第二个线程集在等待结果时就会阻塞。如果第一个线程集运行得快，那么它将等待第二个线程集赶上来。下表显示了jdk1.5中的阻塞队列的操作：

add        增加一个元索                     如果队列已满，则抛出一个IIIegaISlabEepeplian异常
remove   移除并返回队列头部的元素    如果队列为空，则抛出一个NoSuchElementException异常
element  返回队列头部的元素             如果队列为空，则抛出一个NoSuchElementException异常
offer       添加一个元素并返回true       如果队列已满，则返回false
poll         移除并返问队列头部的元素    如果队列为空，则返回null
peek       返回队列头部的元素             如果队列为空，则返回null
put         添加一个元素                      如果队列满，则阻塞
take        移除并返回队列头部的元素     如果队列为空，则阻塞

remove、element、offer 、poll、peek 其实是属于Queue接口。

Queue是一种常见的数据结构，其主要特征在于FIFO（先进先出），Java中的Queue是这样定义的：

public interface Queue<E> extends Collection<E> {
    E element();
    boolean offer(E o);
    E peek();
    E poll();
    E remove();
}

虽然Queue都具有FIFO的特点，但具体输出哪一个元素，Queue的各种实现是不同的，尤其是在排序的情况下，新输入的元素并非放入队列尾部，而是放在适当的位置。Queue的每一种实现都必须指定排序属性（ordering properties）。

Queue可能对存放的元素数目有所限制。这样的Queue成为“有界的”（bounded），在Java.util.concurrent中的某些Queue实现是有界的，而java.util中的Queue实现不是有界的。

Queue的每个操作都有两种方法：

Queue Interface Structure
	Throws exception	Returns special value
Insert	`add(e)`	`offer(e)`
Remove	`remove()`	`poll()`
Examine	`element()`	`peek()`

add方法继承自Collection，当Queue的元素已经到达限制数目时，add会抛出一个IllegalStateException异常；offer方法仅仅定位于应用在有界Queue的情况下，当Queue已经装满时，offer会返回false。

remove和poll方法都删除并返回Queue中的头元素（注意，并不是插入的第一个元素，因为有的Queue实现是排序的）。当Queue为空时，remove抛出NoSuchElementException异常，而poll返回null。

element和peek返回但不删除Queue中的头元素，它们的区别类似remove与poll。

Queue的实现一般并不容许插入null，只有LinkedList是一个意外，它容许插入null，但使用者必须注意，不要与poll和peek方法返回的null值混淆。

Queue的实现一般并不定义基于元素的equals和hashCode方法，而是调用继承自Object的对应方法。

Queue接口并没有定义并行程序中常用的阻塞方法，也就是说，元素进入Queue之前不必检查Queue中是否有足够的空间，不过作为Queue扩展的java.util.concurrent.BlockingQueue接口定义了这些方法。

普通的LinkedList实现并没有定义特殊的排序算法，所以输出元素时会按照插入的顺序：

import java.util.*;
public class Countdown {
    public static void main(String[] args)
            throws InterruptedException {
        int time = 10;
        Queue<Integer> queue = new LinkedList<Integer>();
        for (int i = time; i >= 0; i--)
            queue.add(i);
        while(!queue.isEmpty()) {
            System.out.println(queue.remove());
            Thread.sleep(1000);
        }
    }
}

程序的输出结果为：
10
9
8
…..

如果作一点小更改，采用PriorityQueue

import java.util.*;
public class Countdown {
    public static void main(String[] args)
            throws InterruptedException {
        int time = 10;
        Queue<Integer> queue = new LinkedList<Integer>();
        Queue<Integer> pQueue = new PriorityQueue<Integer>();
        for (int i = time; i >= 0; i--)
            queue.add(i);
        while(!queue.isEmpty()) {
            pQueue.add(queue.remove());           
        }
        while(!pQueue.isEmpty()) {
            System.out.println(pQueue.remove());           
        }
    }
}

则输出结果为：
0
1
2
……

查阅文档可知，PriorityQueue的内部是一个min heap，实际上，观察PriorityQueue的输出也可以发现这一点：

        int time = 10;
        Queue<Integer> queue = new LinkedList<Integer>();
        Queue<Integer> pQueue = new PriorityQueue<Integer>();
        for (int i = time; i >= 0; i--)
            queue.add(i);
        while(!queue.isEmpty()) {
            pQueue.add(queue.remove());           
        }

        System.out.println(pQueue);
        pQueue.remove();
        System.out.println(pQueue);

输出结果为
[0,1,5,4,2,9,6,10,7,8,3]
[1,2,5,4,3,9,6,10,7,8]

实际上就是两个min-heap按照从上至下，从左至右的输出。

数据添加异步解析刷新大数据量redis （——）（一）Java Collection之Queue队列

猜你喜欢