一个没有数据缓冲的BlockingQueue，生产者线程的插入操作(put)，必须等待消费者的移除操作(take)。
容量为 0，不存储数据，只作为数据传递的渠道。导致每次取数据都要先阻塞，直到有数据被放入；同理，每次放数据的时候也会阻塞，直到有消费者来取。
需要注意的是，SynchronousQueue 的容量不是 1 而是 0，因为 SynchronousQueue 不需要去持有元素，它所做的就是直接传递（direct handoff）。由于每当需要传递的时候，SynchronousQueue 会把元素直接从生产者传给消费者，在此期间并不需要做存储，所以如果运用得当，它的效率是很高的。

先工作的一方，将被阻塞
先启动消费者，则消费者被阻塞
先启动生产者，则生产者被阻塞.

应用场景
SynchronousQueue非常适合传递性场景做交换工作，生产者的线程和消费者的线程同步传递某些信息、事件或者任务。
SynchronousQueue的一个使用场景是在线程池里。如果我们不确定来自生产者请求数量，但是这些请求需要很快的处理掉，那么配合SynchronousQueue为每个生产者请求分配一个消费线程是处理效率最高的办法。
Executors.newCachedThreadPool()就使用了SynchronousQueue，这个线程池根据需要（新任务到来时）创建新的线程，如果有空闲线程则会重复使用，线程空闲了60秒后会被回收。

一、原理解析

构造函数

无法初始化队列长度，并且长度总是返回0

  1.     public SynchronousQueue() {
  2.         this(false);
  3.     }
  7.     public SynchronousQueue(boolean fair) {
  8.         transferer = fair ? new TransferQueue<E>() : new TransferStack<E>();
  9.     }
  11.     public int size() {
  12.         return 0;
  13.     }

put方法

  1.     public void put(E e) throws InterruptedException {
  2.         if (e == null) throw new NullPointerException();
  3.         if (transferer.transfer(e, false, 0) == null) {
  4.             Thread.interrupted();
  5.             throw new InterruptedException();
  6.         }
  7.     }

transfer方法队列实现方式

  1.         //两种实现：队列实现；栈实现
  2.         E transfer(E e, boolean timed, long nanos) {
  3.             /* Basic algorithm is to loop trying to take either of
  4.              * two actions:
  5.              *
  6.              * 1. If queue apparently empty or holding same-mode nodes,
  7.              *    try to add node to queue of waiters, wait to be
  8.              *    fulfilled (or cancelled) and return matching item.
  9.              *
  10.              * 2. If queue apparently contains waiting items, and this
  11.              *    call is of complementary mode, try to fulfill by CAS'ing
  12.              *    item field of waiting node and dequeuing it, and then
  13.              *    returning matching item.
  14.              *
  15.              * In each case, along the way, check for and try to help
  16.              * advance head and tail on behalf of other stalled/slow
  17.              * threads.
  18.              *
  19.              * The loop starts off with a null check guarding against
  20.              * seeing uninitialized head or tail values. This never
  21.              * happens in current SynchronousQueue, but could if
  22.              * callers held non-volatile/final ref to the
  23.              * transferer. The check is here anyway because it places
  24.              * null checks at top of loop, which is usually faster
  25.              * than having them implicitly interspersed.
  26.              */
  28.             //put操作：e不为空，take操作：e为空
  29.             QNode s = null; 
  30.             boolean isData = (e != null);//可以标志：是否为put操作
  32.             for (;;) {
  33.                 QNode t = tail;
  34.                 QNode h = head;
  35.                 //初始化队列是，在构造函数时，tail、head已经初始化（QNode h = new QNode(null, false);）
  36.                 if (t == null || h == null)         // saw uninitialized value
  37.                     continue;                       // spin
  39.                 //h==t,表示队列为空。默认情况下，QNode中isData为false。
  40.                 if (h == t || t.isData == isData) { // empty or same-mode
  42.                     //执行到此处 可能是put线程、也可能是take线程
  43.                     QNode tn = t.next;
  44.                     if (t != tail)                  // inconsistent read
  45.                         //如果成立，表示其他线程执行完成put操作
  46.                         continue;
  47.                     if (tn != null) {               // lagging tail
  48.                         //如果成立，表示其他线程执行完成put操作
  49.                         advanceTail(t, tn);
  50.                         continue;
  51.                     }
  52.                     if (timed && nanos <= 0)        // can't wait
  53.                         return null;
  55.                     //构建队列节点，并插入队列尾中
  56.                     if (s == null)
  57.                         s = new QNode(e, isData);
  58.                     if (!t.casNext(null, s))        // failed to link in
  59.                         continue;
  61.                     advanceTail(t, s);              // swing tail and wait
  62.                     //【进行阻塞操作】
  63.                     Object x = awaitFulfill(s, e, timed, nanos);
  65.                     //唤醒后的操作
  66.                     if (x == s) {                   // wait was cancelled
  67.                         clean(t, s);
  68.                         return null;
  69.                     }
  71.                     if (!s.isOffList()) {           // not already unlinked
  72.                         advanceHead(t, s);          // unlink if head
  73.                         if (x != null)              // and forget fields
  74.                             s.item = s;
  75.                         s.waiter = null;
  76.                     }
  77.                     return (x != null) ? (E)x : e;
  79.                     //队列不为null。即已经存在元素
  80.                 } else {                            // complementary-mode
  81.                     //执行到此处 可能是put线程、也可能是take线程
  82.                     QNode m = h.next;               // node to fulfill
  83.                     if (t != tail || m == null || h != head)
  84.                         continue;                   // inconsistent read
  86.                     Object x = m.item;
  87.                     if (isData == (x != null) ||    // m already fulfilled
  88.                         x == m ||                   // m cancelled
  89.                         !m.casItem(x, e)) {         // lost CAS
  90.                         advanceHead(h, m);          // dequeue and retry
  91.                         continue;
  92.                     }
  94.                     //执行唤醒操作。如果当前为put操作，则唤醒阻塞的take线程
  95.                     //如果当前为take操作，则唤醒阻塞的put操作
  96.                     advanceHead(h, m);              // successfully fulfilled
  97.                     LockSupport.unpark(m.waiter);
  98.                     return (x != null) ? (E)x : e;
  99.                 }
  100.             }
  101.         }

awaitFulfill方法

阻塞

  1.         Object awaitFulfill(QNode s, E e, boolean timed, long nanos) {
  2.             /* Same idea as TransferStack.awaitFulfill */
  3.             //timed==true,则表示阻塞指定时间，否则一直阻塞，直到被唤醒
  4.             final long deadline = timed ? System.nanoTime() + nanos : 0L;
  6.             获取当前线程，等待阻塞操作
  7.             Thread w = Thread.currentThread();
  9.             //获取自旋次数
  10.             //不是队列中的节点，则spins=0。
  11.             int spins = ((head.next == s) ?
  12.                          (timed ? maxTimedSpins : maxUntimedSpins) : 0);
  13.             for (;;) {
  15.                 //如果当前线程w，执行中断操作。则移除节点
  16.                 if (w.isInterrupted())
  17.                     s.tryCancel(e);
  18.                 Object x = s.item;
  19.                 if (x != e)
  20.                     return x;
  21.                 if (timed) {
  22.                     nanos = deadline - System.nanoTime();
  23.                     if (nanos <= 0L) {
  24.                         s.tryCancel(e);
  25.                         continue;
  26.                     }
  27.                 }
  28.                 if (spins > 0)
  29.                     --spins;
  30.                 else if (s.waiter == null)
  31.                     s.waiter = w;
  32.                 else if (!timed)
  33.                     //执行阻塞。需要等待被唤醒
  34.                     LockSupport.park(this);
  35.                 else if (nanos > spinForTimeoutThreshold)
  36.                     //阻塞指定时间
  37.                     LockSupport.parkNanos(this, nanos);
  38.             }
  39.         }

take方法

  1.     public E take() throws InterruptedException {
  2.         E e = transferer.transfer(null, false, 0);
  3.         if (e != null)
  4.             return e;
  5.         Thread.interrupted();
  6.         throw new InterruptedException();
  7.     }