// 創(chuàng)建一個最初為空的 ConcurrentLinkedQueue。
ConcurrentLinkedQueue()
// 創(chuàng)建一個最初包含給定 collection 元素的 ConcurrentLinkedQueue，按照此 collection 迭代器的遍歷順序來添加元素。
ConcurrentLinkedQueue(Collection<? extends E> c)
// 將指定元素插入此隊列的尾部。
boolean add(E e)
// 如果此隊列包含指定元素，則返回 true。
boolean contains(Object o)
// 如果此隊列不包含任何元素，則返回 true。
boolean isEmpty()
// 返回在此隊列元素上以恰當順序進行迭代的迭代器。
Iterator<E> iterator()
// 將指定元素插入此隊列的尾部。
boolean offer(E e)
// 獲取但不移除此隊列的頭；如果此隊列為空，則返回 null。
E peek()
// 獲取并移除此隊列的頭，如果此隊列為空，則返回 null。
E poll()
// 從隊列中移除指定元素的單個實例（如果存在）。
boolean remove(Object o)
// 返回此隊列中的元素數量。
int size()
// 返回以恰當順序包含此隊列所有元素的數組。
Object[] toArray()
// 返回以恰當順序包含此隊列所有元素的數組；返回數組的運行時類型是指定數組的運行時類型。
<T> T[] toArray(T[] a)

public ConcurrentLinkedQueue() {
 head = tail = new Node<E>(null);
}

private transient volatile Node<E> head;
private transient volatile Node<E> tail;

private static class Node<E> {
 volatile E item;
 volatile Node<E> next;
 Node(E item) {
 UNSAFE.putObject(this, itemOffset, item);
 }
 boolean casItem(E cmp, E val) {
 return UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);
 }
 void lazySetNext(Node<E> val) {
 UNSAFE.putOrderedObject(this, nextOffset, val);
 }
 boolean casNext(Node<E> cmp, Node<E> val) {
 return UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
 }
 // Unsafe mechanics
 private static final sun.misc.Unsafe UNSAFE;
 private static final long itemOffset;
 private static final long nextOffset;
 static {
 try {
  UNSAFE = sun.misc.Unsafe.getUnsafe();
  Class k = Node.class;
  itemOffset = UNSAFE.objectFieldOffset
  (k.getDeclaredField("item"));
  nextOffset = UNSAFE.objectFieldOffset
  (k.getDeclaredField("next"));
 } catch (Exception e) {
  throw new Error(e);
 }
 }
}

public boolean add(E e) {
 return offer(e);
}

public boolean offer(E e) {
 // 檢查e是不是null，是的話拋出NullPointerException異常。
 checkNotNull(e);
 // 創(chuàng)建新的節(jié)點
 final Node<E> newNode = new Node<E>(e);

 // 將“新的節(jié)點”添加到鏈表的末尾。
 for (Node<E> t = tail, p = t;;) {
 Node<E> q = p.next;
 // 情況1：q為空
 if (q == null) {
  // CAS操作：如果“p的下一個節(jié)點為null”(即p為尾節(jié)點)，則設置p的下一個節(jié)點為newNode。
  // 如果該CAS操作成功的話，則比較“p和t”(若p不等于t，則設置newNode為新的尾節(jié)點)，然后返回true。
  // 如果該CAS操作失敗，這意味著“其它線程對尾節(jié)點進行了修改”，則重新循環(huán)。
  if (p.casNext(null, newNode)) {
  if (p != t) // hop two nodes at a time
   casTail(t, newNode); // Failure is OK.
  return true;
  }
 }
 // 情況2：p和q相等
 else if (p == q)
  p = (t != (t = tail)) ? t : head;
 // 情況3：其它
 else
  p = (p != t && t != (t = tail)) ? t : q;
 }
}

if (p==t) {
 p = q;
} else {
 Node<E> tmp=t;
 t = tail;
 if (tmp==t) {
 p=q;
 } else {
 p=t;
 }
}

private static void checkNotNull(Object v) {
 if (v == null)
 throw new NullPointerException();
} 

public E poll() {
 // 設置“標記”
 restartFromHead:
 for (;;) {
 for (Node<E> h = head, p = h, q;;) {
  E item = p.item;

  // 情況1
  // 表頭的數據不為null，并且“設置表頭的數據為null”這個操作成功的話;
  // 則比較“p和h”(若p!=h，即表頭發(fā)生了變化，則更新表頭，即設置表頭為p)，然后返回原表頭的item值。
  if (item != null && p.casItem(item, null)) {
  if (p != h) // hop two nodes at a time
   updateHead(h, ((q = p.next) != null) ? q : p);
  return item;
  }
  // 情況2
  // 表頭的下一個節(jié)點為null，即鏈表只有一個“內容為null的表頭節(jié)點”。則更新表頭為p，并返回null。
  else if ((q = p.next) == null) {
  updateHead(h, p);
  return null;
  }
  // 情況3
  // 這可能到由于“情況4”的發(fā)生導致p=q，在該情況下跳轉到restartFromHead標記重新操作。
  else if (p == q)
  continue restartFromHead;
  // 情況4
  // 設置p為q
  else
  p = q;
 }
 }
}

final void updateHead(Node<E> h, Node<E> p) {
 if (h != p && casHead(h, p))
 h.lazySetNext(h);
}

void lazySetNext(Node<E> val) {
 UNSAFE.putOrderedObject(this, nextOffset, val);
}

import java.util.*;
 import java.util.concurrent.*;
 /*
 * ConcurrentLinkedQueue是“線程安全”的隊列，而LinkedList是非線程安全的。
 *
 * 下面是“多個線程同時操作并且遍歷queue”的示例
 * (01) 當queue是ConcurrentLinkedQueue對象時，程序能正常運行。
 * (02) 當queue是LinkedList對象時，程序會產生ConcurrentModificationException異常。
 *
 *
 */
 public class ConcurrentLinkedQueueDemo1 {
 // TODO: queue是LinkedList對象時，程序會出錯。
 //private static Queue<String> queue = new LinkedList<String>();
 private static Queue<String> queue = new ConcurrentLinkedQueue<String>();
 public static void main(String[] args) {
  // 同時啟動兩個線程對queue進行操作！
  new MyThread("ta").start();
  new MyThread("tb").start();
 }
 private static void printAll() {
  String value;
  Iterator iter = queue.iterator();
  while(iter.hasNext()) {
  value = (String)iter.next();
  System.out.print(value+", ");
  }
  System.out.println();
 }
 private static class MyThread extends Thread {
  MyThread(String name) {
  super(name);
  }
  @Override
  public void run() {
   int i = 0;
  while (i++ < 6) {
   // “線程名” + "-" + "序號"
   String val = Thread.currentThread().getName()+i;
   queue.add(val);
   // 通過“Iterator”遍歷queue。
   printAll();
  }
  }
 }
 }

ta1, ta1, tb1, tb1,
ta1, ta1, tb1, tb1, ta2, ta2, tb2, 
tb2, 
ta1, ta1, tb1, tb1, ta2, ta2, tb2, tb2, ta3, tb3, 
ta3, ta1, tb3, tb1, ta4, 
ta2, ta1, tb2, tb1, ta3, ta2, tb3, tb2, ta4, ta3, tb4, 
tb3, ta1, ta4, tb1, tb4, ta2, ta5, 
tb2, ta1, ta3, tb1, tb3, ta2, ta4, tb2, tb4, ta3, ta5, tb3, tb5, 
ta4, ta1, tb4, tb1, ta5, ta2, tb5, tb2, ta6, 
ta3, ta1, tb3, tb1, ta4, ta2, tb4, tb2, ta5, ta3, tb5, tb3, ta6, ta4, tb6, 
tb4, ta5, tb5, ta6, tb6,