Android开源框架：Universal-Image-Loader解析（四）TaskProcess

Universal-Image-Loader中，对Task的处理有两种方法：FIFO，LIFO

在core/assist下的deque包中，其主要是定义了LIFOLinkedBlockingDeque，其他的几个均在java.util和java.util.concurr中

下面我们对queue和deque及其相关的类撸一撸，看看它们的区别

1. Queue：队列， 继承于Collection，定义了几个与队列相关的方法

2. Deque：双向队列，继承于Queue，定义了和双向操作相关的方法

3. BlockingQueue：阻塞队列

4. BlockingDeque：双向阻塞队列

5. AbstractQueue： 实现了队列的几个基本方法，

6. LinkedBlockingQueue：线程安全，阻塞队列，默认长度是Integer.MAX_VALUE

    按 FIFO（先进先出）排序元素。队列的头部 是在队列中时间最长的元素。队列的尾部 是在队列中时间最短的元素。 链接队列的吞吐量通常要高于基于数组的队列。

/**
     * Linked list node class，单向的列表
     */
    static class Node<E> {
        E item;
        /**
         * One of:
         * - the real successor Node
         * - this Node, meaning the successor is head.next
         * - null, meaning there is no successor (this is the last node)
         */

        Node<E> next;
        Node(E x) { item = x; }
    }

7. LinkedBlockingDeque：线程安全，双向阻塞队列，其实现主要是基于两个Node，默认长度是Integer.MAX_VALUE

/** Doubly-linked list node class 双向链表*/
    static final class Node<E> {
        /**
         * The item, or null if this node has been removed.
         */
        E item;

        /**
         * One of:
         * - the real predecessor Node
         * - this Node, meaning the predecessor is tail
         * - null, meaning there is no predecessor
         */
        Node<E> prev;

        /**
         * One of:
         * - the real successor Node
         * - this Node, meaning the successor is head
         * - null, meaning there is no successor
         */
        Node<E> next;

        Node(E x) {
            item = x;
        }
    }

    /**
     * Pointer to first node.头节点
     * Invariant: (first == null && last == null) ||
     *            (first.prev == null && first.item != null)
     */
    transient Node<E> first;

    /**
     * Pointer to last node.尾节点
     * Invariant: (first == null && last == null) ||
     *            (last.next == null && last.item != null)
     */
    transient Node<E> last;

8. LIFOLinkedBlockingDeque：后进先出，双向阻塞队列，仅仅override两个方法

@Override
    public boolean offer(T e) {
        return super.offerFirst(e);
    }

    /**
     * Retrieves and removes the first element of this deque. This method differs from {@link #pollFirst pollFirst} only
     * in that it throws an exception if this deque is empty.
     * 
     * @return the head of this deque
     * @throws NoSuchElementException
     *             if this deque is empty
     */
    @Override
    public T remove() {
        return super.removeFirst();
    }

阻塞队列的工作原理：一个线程（生产者）放入任务，另外一个线程（消费者）取出任务

上图参考链接：http://www.cnblogs.com/qiengo/archive/2012/12/19/2824971.html