ConcurrentLinkedDeque--未完成

1、简介

1.1 介绍

基于链接节点的无界并发deque 。 并发插入，删除和访问操作可以跨多个线程安全执行。 A ConcurrentLinkedDeque是许多线程将共享对公共集合的访问的适当选择。 像大多数其他并发集合实现一样，此类不允许使用null元素。
这是一个双向链表
size方法不是一个准确的操作

1.2 构造

//构造一个空的构造。ConcurrentLinkedDeque()//构造最初包含给定集合的元素的deque，以集合的迭代器的遍历顺序添加。ConcurrentLinkedDeque(Collection<? extends E> c)

1.3 继承

java.lang.Object    java.util.AbstractCollection<E>        java.util.concurrent.ConcurrentLinkedDeque<E>

1.4 主要方法

boolean add(E e)//在此deque的尾部插入指定的元素。boolean addAll(Collection<? extends E> c)//按指定集合的迭代器返回的顺序将指定集合中的所有元素追加到该deque的末尾。void    addFirst(E e)//在此deque前面插入指定的元素。void    addLast(E e)//在此deque的末尾插入指定的元素。void    clear()//从这个deque中删除所有的元素。boolean contains(Object o)//返回 true如果这个deque包含至少一个元素 e ，这样 o.equals(e) 。E   element()//检索但不删除由此deque表示的队列的头部（换句话说，该deque的第一个元素）。E   getFirst()//检索，但不删除，这个deque的第一个元素。E   getLast()//检索，但不删除，这个deque的最后一个元素。boolean offer(E e)//在此deque的尾部插入指定的元素。boolean offerFirst(E e)//在此deque前面插入指定的元素。boolean offerLast(E e)//在此deque的末尾插入指定的元素。E   peek()//检索但不删除由此deque表示的队列的头（换句话说，该deque的第一个元素），如果此deque为空，则返回 null 。E   peekFirst()//检索但不删除此deque的第一个元素，如果此deque为空，则返回 null 。E   peekLast()//检索但不删除此deque的最后一个元素，如果此deque为空，则返回 null 。E   poll()//检索并删除由此deque表示的队列的头部（换句话说，该deque的第一个元素），如果此deque为空，则返回 null 。E   pollFirst()//检索并删除此deque的第一个元素，如果此deque为空，则返回 null 。E   pollLast()//检索并删除此deque的最后一个元素，如果此deque为空，则返回 null 。E   pop()//从这个deque表示的堆栈中弹出一个元素。void    push(E e)//将元素推送到由此deque代表的堆栈（换句话说，在该deque的头部），如果可以立即执行，而不违反容量限制，则抛出 IllegalStateException如果当前没有可用空间）。E   remove()//检索并删除由此deque表示的队列的头（换句话说，该deque的第一个元素）。boolean remove(Object o)//删除第一个元素 e ，使 o.equals(e) ，如果这样一个元素存在于这个deque。E   removeFirst()//检索并删除此deque的第一个元素。boolean removeFirstOccurrence(Object o)//删除第一个元素 e ，使 o.equals(e) ，如果这样一个元素存在于这个deque。E   removeLast()//检索并删除此deque的最后一个元素。boolean removeLastOccurrence(Object o)//删除最后一个元素 e ，使 o.equals(e) ，如果这样的元素存在于这个deque。

2、源代码

public class ConcurrentLinkedDeque<E>    extends AbstractCollection<E>    implements Deque<E>, java.io.Serializable {    //头节点    private transient volatile Node<E> head;    //尾节点    private transient volatile Node<E> tail;    //节点类    static final class Node<E> {        //双向        volatile Node<E> prev;        volatile E item;        volatile Node<E> next;        Node() {  // default constructor for NEXT_TERMINATOR, PREV_TERMINATOR        }        /**         * Constructs a new node.  Uses relaxed write because item can         * only be seen after publication via casNext or casPrev.         */        Node(E item) {            UNSAFE.putObject(this, itemOffset, item);        }        boolean casItem(E cmp, E val) {            return UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);        }        //设置next节点        void lazySetNext(Node<E> val) {            UNSAFE.putOrderedObject(this, nextOffset, val);        }        //替换next节点        boolean casNext(Node<E> cmp, Node<E> val) {            return UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);        }        void lazySetPrev(Node<E> val) {            UNSAFE.putOrderedObject(this, prevOffset, val);        }        boolean casPrev(Node<E> cmp, Node<E> val) {            return UNSAFE.compareAndSwapObject(this, prevOffset, cmp, val);        }        // Unsafe mechanics        private static final sun.misc.Unsafe UNSAFE;        private static final long prevOffset;        private static final long itemOffset;        private static final long nextOffset;        static {            try {                UNSAFE = sun.misc.Unsafe.getUnsafe();                Class<?> k = Node.class;                prevOffset = UNSAFE.objectFieldOffset                    (k.getDeclaredField("prev"));                itemOffset = UNSAFE.objectFieldOffset                    (k.getDeclaredField("item"));                nextOffset = UNSAFE.objectFieldOffset                    (k.getDeclaredField("next"));            } catch (Exception e) {                throw new Error(e);            }        }    }    //插入头元素    private void linkFirst(E e) {        checkNotNull(e);        //新建节点        final Node<E> newNode = new Node<E>(e);        restartFromHead:        for (;;)            for (Node<E> h = head, p = h, q;;) {                if ((q = p.prev) != null &&                    (q = (p = q).prev) != null)                    // Check for head updates every other hop.                    // If p == q, we are sure to follow head instead.                    p = (h != (h = head)) ? h : q;                else if (p.next == p) // PREV_TERMINATOR                    continue restartFromHead;                else {                    // p is first node                    //将p添加到队列头                    newNode.lazySetNext(p); // CAS piggyback                    if (p.casPrev(null, newNode)) {                        // Successful CAS is the linearization point                        // for e to become an element of this deque,                        // and for newNode to become "live".                        if (p != h) // hop two nodes at a time                            //将head赋给newNode                            casHead(h, newNode);  // Failure is OK.                        return;                    }                    // Lost CAS race to another thread; re-read prev                }            }    }    //添加到队列尾    private void linkLast(E e) {        checkNotNull(e);        final Node<E> newNode = new Node<E>(e);        restartFromTail:        for (;;)            for (Node<E> t = tail, p = t, q;;) {                if ((q = p.next) != null &&                    (q = (p = q).next) != null)                    // Check for tail updates every other hop.                    // If p == q, we are sure to follow tail instead.                    p = (t != (t = tail)) ? t : q;                else if (p.prev == p) // NEXT_TERMINATOR                    continue restartFromTail;                else {                    // p is last node                    newNode.lazySetPrev(p); // CAS piggyback                    if (p.casNext(null, newNode)) {                        // Successful CAS is the linearization point                        // for e to become an element of this deque,                        // and for newNode to become "live".                        if (p != t) // hop two nodes at a time                            casTail(t, newNode);  // Failure is OK.                        return;                    }                    // Lost CAS race to another thread; re-read next                }            }    }}