AbstractQueue简介： http://donald-draper.iteye.com/blog/2363608
ConcurrentLinkedQueue解析： http://donald-draper.iteye.com/blog/2363874
BlockingQueue接口的定义： http://donald-draper.iteye.com/blog/2363942
LinkedBlockingQueue解析： http://donald-draper.iteye.com/blog/2364007
ArrayBlockingQueue解析： http://donald-draper.iteye.com/blog/2364034
PriorityBlockingQueue解析： http://donald-draper.iteye.com/blog/2364100
SynchronousQueue解析上-TransferStack： http://donald-draper.iteye.com/blog/2364622
由于篇幅问题，上一篇只讲到TransferStack，而没讲到TransferQueue和其余部分，试着看看这篇能不能
讲完，不能讲完的话，再分一篇讲。
先回顾一下上一篇：
SynchronousQueue阻塞队列，每次插入操作必须等待一个协同的移除线程，反之亦然。
SynchronousQueue同步队列没有容量，可以说，没有一个容量。由于队列中只有在消费线程，
尝试消费元素的时候，才会出现元素，所以不能进行peek操作；不能用任何方法，生产元素，除非有消费者在尝试消费元素，同时由于队列中没有元素，所以不能迭代。head是第一个生产线程尝试生产的元素；如果没有这样的生产线程，那么没有元素可利用，remove和poll操作将会返回null。SynchronousQueue实际一个空集合类。同时同步队列不允许为null。同步队列支持生产者和消费者等待的公平性策略。默认情况下，不能保证生产消费的顺序。如果一个同步队列构造为公平性，则可以线程以FIFO访问队列元素。当时非公平策略用的是
TransferStack，公平策略用的是TransferQueue；TransferStack和TransferQueue是存放等待操作线程的描述，从TransferStack中Snode节点可以看出：节点关联一个等待线程waiter，后继next，匹配节点match，节点元素item和模式mode；模式由三种，REQUEST节点表示消费者等待消费资源，DATA表示生产者等待生产资源。FULFILLING节点表示生产者正在给等待资源的消费者补给资源，或生产者在等待消费者消费资源。当有线程take/put操作时，查看栈头，如果是空队列，或栈头节点的模式与要放入的节点模式相同；如果是超时等待，判断时间是否小于0，小于0则取消节点等待；如果非超时，则将创建的新节点入栈成功，即放在栈头，自旋等待匹配节点（timed决定超时，不超时）；如果匹配返回的是自己，节点取消等待，从栈中移除，并遍历栈移除取消等待的节点；匹配成功，两个节点同时出栈，REQUEST模式返回，匹配到的节点元素（DATA），DATA模式返回节点元素（REQUEST）。如果与栈头节点的模式不同且不为FULFILLING，匹配节点，成功者，两个节点同时出栈，REQUEST模式返回，匹配到的节点元素（DATA），DATA模式返回节点元素（REQUEST）。如果栈头为FULFILLING，找出栈头的匹配节点，栈头与匹配到的节点同时出栈。从分析非公平模式下的TransferStack，可以看出一个REQUEST操作必须同时伴随着一个DATA操作，一个DATA操作必须同时伴随着一个REQUEST操作，这也是同步队列的命名中含Synchronous原因。SynchronousQueue像一个管道，一个操作必须等待另一个操作的发生。
/** Dual Queue */
static final class TransferQueue extends Transferer {
/*
* This extends Scherer-Scott dual queue algorithm, differing,
* among other ways, by using modes within nodes rather than
* marked pointers. The algorithm is a little simpler than
* that for stacks because fulfillers do not need explicit
* nodes, and matching is done by CAS'ing QNode.item field
* from non-null to null (for put) or vice versa (for take).
本算法实现拓展了Scherer-Scott双队列算法，不同的是用节点模式，
而不是标记指针来区分节点操作类型。这个算法比栈算法的实现简单，
因为fulfillers需要明确指定节点，同时匹配节点用CAS操作QNode的
元素field即可，put操作从非null到null，反则亦然，take从null到非null。
*/
/** Node class for TransferQueue. */
static final class QNode {
volatile QNode next; // next node in queue 后继
volatile Object item; // CAS'ed to or from null 节点元素
volatile Thread waiter; // to control park/unpark 等待线程
final boolean isData; //是否为DATA模式
//设置元素和模式
QNode(Object item, boolean isData) {
this.item = item;
this.isData = isData;
}
//设置节点的后继
boolean casNext(QNode cmp, QNode val) {
return next == cmp &&
UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
}
//设置节点的元素
boolean casItem(Object cmp, Object val) {
return item == cmp &&
UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);
}
/**
* Tries to cancel by CAS'ing ref to this as item.
取消节点等待，元素指向自己
*/
void tryCancel(Object cmp) {
UNSAFE.compareAndSwapObject(this, itemOffset, cmp, this);
}
//是否取消等待
boolean isCancelled() {
return item == this;
}
/**
* Returns true if this node is known to be off the queue
* because its next pointer has been forgotten due to
* an advanceHead operation.
是否出队列
*/
boolean isOffList() {
return next == this;
}
// 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 = QNode.class;
itemOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("item"));
nextOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("next"));
} catch (Exception e) {
throw new Error(e);
}
}
}
/** Head of queue 队列头节点*/
transient volatile QNode head;
/** Tail of queue 队列尾节点*/
transient volatile QNode tail;
/**
* Reference to a cancelled node that might not yet have been
* unlinked from queue because it was the last inserted node
* when it cancelled.
刚入队列的节点，取消等待，但还没有出队列的节点，
*/
transient volatile QNode cleanMe;
TransferQueue() {
//构造队列
QNode h = new QNode(null, false); // initialize to dummy node.
head = h;
tail = h;
}
/**
* Tries to cas nh as new head; if successful, unlink
* old head's next node to avoid garbage retention.
尝试设置新的队头节点为nh，并比较旧头节点，成功则，解除旧队列头节点的next链接，及指向自己
*/
void advanceHead(QNode h, QNode nh) {
if (h == head &&
UNSAFE.compareAndSwapObject(this, headOffset, h, nh))
h.next = h; // forget old next
}
/**
* Tries to cas nt as new tail.
尝试设置队尾
*/
void advanceTail(QNode t, QNode nt) {
if (tail == t)
UNSAFE.compareAndSwapObject(this, tailOffset, t, nt);
}
/**
* Tries to CAS cleanMe slot.
尝试设置取消等待节点为val。并比较旧的等待节点是否为cmp
*/
boolean casCleanMe(QNode cmp, QNode val) {
return cleanMe == cmp &&
UNSAFE.compareAndSwapObject(this, cleanMeOffset, cmp, val);
}
/**
* Puts or takes an item.
生产或消费一个元素
*/
Object transfer(Object e, boolean timed, long nanos) {
/* Basic algorithm is to loop trying to take either of
* two actions:
*
基本算法是循环尝试，执行下面两个步中的，其中一个：
* 1. If queue apparently empty or holding same-mode nodes,
* try to add node to queue of waiters, wait to be
* fulfilled (or cancelled) and return matching item.
*
1.如果队列为空，或队列中为相同模式的节点，尝试节点入队列等待，
直到fulfilled，返回匹配元素，或者由于中断，超时取消等待。
* 2. If queue apparently contains waiting items, and this
* call is of complementary mode, try to fulfill by CAS'ing
* item field of waiting node and dequeuing it, and then
* returning matching item.
*
2.如果队列中包含节点，transfer方法被一个协同模式的节点调用，
则尝试补给或填充等待线程节点的元素，并出队列，返回匹配元素。
* In each case, along the way, check for and try to help
* advance head and tail on behalf of other stalled/slow
* threads.
*
在每一种情况，执行的过程中，检查和尝试帮助其他stalled/slow线程移动队列头和尾节点
* The loop starts off with a null check guarding against
* seeing uninitialized head or tail values. This never
* happens in current SynchronousQueue, but could if
* callers held non-volatile/final ref to the
* transferer. The check is here anyway because it places
* null checks at top of loop, which is usually faster
* than having them implicitly interspersed.
循环开始，首先进行null检查，防止为初始队列头和尾节点。当然这种情况，
在当前同步队列中，不可能发生，如果调用持有transferer的non-volatile/final引用，
可能出现这种情况。一般在循环的开始，都要进行null检查，检查过程非常快，不用过多担心
性能问题。
*/
QNode s = null; // constructed/reused as needed
//如果元素e不为null，则为DATA模式，否则为REQUEST模式
boolean isData = (e != null);
for (;;) {
QNode t = tail;
QNode h = head;
//如果队列头或尾节点没有初始化，则跳出本次自旋
if (t == null || h == null) // saw uninitialized value
continue; // spin
if (h == t || t.isData == isData) { // empty or same-mode
//如果队列为空，或当前节点与队尾模式相同
QNode tn = t.next;
if (t != tail) // inconsistent read
//如果t不是队尾，非一致性读取，跳出本次自旋
continue;
if (tn != null) { // lagging tail
//如果t的next不为null，设置新的队尾，跳出本次自旋
advanceTail(t, tn);
continue;
}
if (timed && nanos <= 0) // can't wait
//如果超时，且超时时间小于0，则返回null
return null;
if (s == null)
//根据元素和模式构造节点
s = new QNode(e, isData);
if (!t.casNext(null, s)) // failed to link in
//新节点入队列
continue;
//设置队尾为当前节点
advanceTail(t, s); // swing tail and wait
//自旋或阻塞直到节点被fulfilled
Object x = awaitFulfill(s, e, timed, nanos);
if (x == s) { // wait was cancelled
//如果s指向自己，s出队列，并清除队列中取消等待的线程节点
clean(t, s);
return null;
}
if (!s.isOffList()) { // not already unlinked
//如果s节点已经不再队列中，移除
advanceHead(t, s); // unlink if head
if (x != null) // and forget fields
s.item = s;
s.waiter = null;
}
//如果自旋等待匹配的节点元素不为null，则返回x，否则返回e
return (x != null) ? x : e;
} else { // complementary-mode
//如果队列不为空，且与队头的模式不同，及匹配成功
QNode m = h.next; // node to fulfill
if (t != tail || m == null || h != head)
//如果h不为当前队头，则返回，即读取不一致
continue; // inconsistent read
Object x = m.item;
if (isData == (x != null) || // m already fulfilled
x == m || // m cancelled
!m.casItem(x, e)) { // lost CAS
//如果队头后继，取消等待，则出队列
advanceHead(h, m); // dequeue and retry
continue;
}
//否则匹配成功
advanceHead(h, m); // successfully fulfilled
//unpark等待线程
LockSupport.unpark(m.waiter);
//如果匹配节点元素不为null，则返回x，否则返回e，即take操作，返回等待put线程节点元素，
//put操作，返回put元素
return (x != null) ? x : e;
}
}
}
/**
* Spins/blocks until node s is fulfilled.
*
自旋或阻塞直到节点被fulfilled
* @param s the waiting node，等待节点
* @param e the comparison value for checking match，检查匹配的比较元素
* @param timed true if timed wait 是否超时等待
* @param nanos timeout value 超时等待时间
* @return matched item, or s if cancelled 成功返回匹配元素，取消返回等待元素
*/
Object awaitFulfill(QNode s, Object e, boolean timed, long nanos) {
/* Same idea as TransferStack.awaitFulfill 这里与栈中的实现思路是一样的*/
//获取超时的当前时间，当前线程，自旋数
long lastTime = timed ? System.nanoTime() : 0;
Thread w = Thread.currentThread();
int spins = ((head.next == s) ?
(timed ? maxTimedSpins : maxUntimedSpins) : 0);
for (;;) {
if (w.isInterrupted())
//如果中断，则取消等待
s.tryCancel(e);
Object x = s.item;
if (x != e)
return x;//如果s的节点的元素不相等，则返回x,即s节点指向自身，等待clean
if (timed) {
long now = System.nanoTime();
nanos -= now - lastTime;
lastTime = now;
if (nanos <= 0) {
//如果超时，则取消等待
s.tryCancel(e);
continue;
}
}
if (spins > 0)
//自旋数减一
--spins;
else if (s.waiter == null)
//如果是节点的等待线程为空，则设置为当前线程
s.waiter = w;
else if (!timed)
//非超时，则park
LockSupport.park(this);
else if (nanos > spinForTimeoutThreshold)
//超时时间大于自旋时间，则超时park
LockSupport.parkNanos(this, nanos);
}
}
/**
* Gets rid of cancelled node s with original predecessor pred.
移除队列中取消等待的线程节点
*/
void clean(QNode pred, QNode s) {
s.waiter = null; // forget thread
/*
* At any given time, exactly one node on list cannot be
* deleted -- the last inserted node. To accommodate this,
* if we cannot delete s, we save its predecessor as
* "cleanMe", deleting the previously saved version
* first. At least one of node s or the node previously
* saved can always be deleted, so this always terminates.
在任何时候，最后一个节点入队列时，队列中都有可能存在取消等待，但没有删除的节点。
为了将这些节点删除，如果我们不能删除最后入队列的节点，我们可以用cleanMe记录它的前驱，
删除cleanMe后继节点。s节点和cleanMe后继节点至少一个删除，则停止。
*/
while (pred.next == s) { // Return early if already unlinked
//如果s为队尾节点，且前驱为旧队尾
QNode h = head;
QNode hn = h.next; // Absorb cancelled first node as head
if (hn != null && hn.isCancelled()) {
//如果队头不为空，且取消等待，设置后继为新的队头元素
advanceHead(h, hn);
continue;
}
QNode t = tail; // Ensure consistent read for tail
if (t == h)
//空队列，则返回
return;
QNode tn = t.next;
if (t != tail)
//如果队尾有变化，跳出循环
continue;
if (tn != null) {
//如果队尾后继不为null，则设置新的队尾
advanceTail(t, tn);
continue;
}
if (s != t) { // If not tail, try to unsplice
QNode sn = s.next;
if (sn == s || pred.casNext(s, sn))
//s节点指向自己，则返回
return;
}
QNode dp = cleanMe;
if (dp != null) { // Try unlinking previous cancelled node
//移除前一个取消等待的节点
QNode d = dp.next;
QNode dn;
if (d == null || // d is gone or
d == dp || // d is off list or
!d.isCancelled() || // d not cancelled or
(d != t && // d not tail and
(dn = d.next) != null && // has successor
dn != d && // that is on list
dp.casNext(d, dn))) // d unspliced
casCleanMe(dp, null);
if (dp == pred)
return; // s is already saved node
} else if (casCleanMe(null, pred))
//先前取消等待的节点为null，则将cleanMe设为刚取消等待节点的前驱
return; // Postpone cleaning s
}
}
private static final sun.misc.Unsafe UNSAFE;
private static final long headOffset;
private static final long tailOffset;
private static final long cleanMeOffset;
static {
try {
UNSAFE = sun.misc.Unsafe.getUnsafe();
Class k = TransferQueue.class;
headOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("head"));
tailOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("tail"));
cleanMeOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("cleanMe"));
} catch (Exception e) {
throw new Error(e);
}
}
}
到这里TransferQueue我们已经看完，我们简单的总结一下：
TransferQueue在执行take/put操作时，首先根据元素是否判断当前节点的模式，
如果元素为null则为REQUEST（take）模式，否则为DATA模式（put）。
然后自旋匹配节点，如果队列头或尾节点没有初始化，则跳出本次自旋，
如果队列为空，或当前节点与队尾模式相同，自旋或阻塞直到节点被fulfilled；
如果队列不为空，且与队头的模式不同，及匹配成功，出队列，如果是REQUEST操作，
返回匹配到节点的元素，如果为DATA操作，返回当前节点元素。
TransferQueue相对于TransferStack来说，操作匹配过程更简单，TransferStack为非公平策略下的实现LIFO，TransferQueue是公平策略下的实现FIFO。TransferQueue中的QNODE与TransferStack的SNODE节点有所不同处理后继next，等待线程，节点元素外，SNODE还有一个对应的模式REQUEST，DATA或FULFILLING，而QNODE中用一个布尔值isData来表示模式，这个模式的判断主要根据是元素是否为null，如果为null，则为REQUEST（take）模式，否则为DATA模式（put）。
再来看SynchronousQueue的构造和相关操作
构造：
先看内部Transferer的声明：
/**
* The transferer. Set only in constructor, but cannot be declared
* as final without further complicating serialization. Since
* this is accessed only at most once per public method, there
* isn't a noticeable performance penalty for using volatile
* instead of final here.
transferer在构造函数中初始化，没有进一步的复杂序列化的情况下，不需要
声明为final。由于transferer至多在public方法中用一次，所以volatile取代final不会有
太多的性能代价。
*/
private transient volatile Transferer transferer;
/**
* Creates a <tt>SynchronousQueue</tt> with nonfair access policy.
*/
public SynchronousQueue() {
//默认为非公平，栈
this(false);
}
/**
* Creates a <tt>SynchronousQueue</tt> with the specified fairness policy.
*
* @param fair if true, waiting threads contend in FIFO order for
* access; otherwise the order is unspecified.
*/
public SynchronousQueue(boolean fair) {
transferer = fair ? new TransferQueue() : new TransferStack();
}
如果公平则为TransferQueue，否则为TransferStack。
再看其他操作：
put操作：
/**
* Adds the specified element to this queue, waiting if necessary for
* another thread to receive it.
*
* @throws InterruptedException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
public void put(E o) throws InterruptedException {
if (o == null) throw new NullPointerException();
if (transferer.transfer(o, false, 0) == null) {
//返回为null，则put失败，中断当前线程
Thread.interrupted();
throw new InterruptedException();
}
}
超时offer：
/**
* Inserts the specified element into this queue, waiting if necessary
* up to the specified wait time for another thread to receive it.
*
* @return <tt>true</tt> if successful, or <tt>false</tt> if the
* specified waiting time elapses before a consumer appears.
* @throws InterruptedException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
public boolean offer(E o, long timeout, TimeUnit unit)
throws InterruptedException {
if (o == null) throw new NullPointerException();
if (transferer.transfer(o, true, unit.toNanos(timeout)) != null)
return true;
if (!Thread.interrupted())
return false;
throw new InterruptedException();
}
再看offer
/**
* Inserts the specified element into this queue, if another thread is
* waiting to receive it.
*
* @param e the element to add
* @return <tt>true</tt> if the element was added to this queue, else
* <tt>false</tt>
* @throws NullPointerException if the specified element is null
*/
public boolean offer(E e) {
if (e == null) throw new NullPointerException();
return transferer.transfer(e, true, 0) != null;
}
take操作：
/**
* Retrieves and removes the head of this queue, waiting if necessary
* for another thread to insert it.
*
* @return the head of this queue
* @throws InterruptedException {@inheritDoc}
*/
public E take() throws InterruptedException {
Object e = transferer.transfer(null, false, 0);
if (e != null)
return (E)e;
Thread.interrupted();
throw new InterruptedException();
}
超时poll操作:
/**
* Retrieves and removes the head of this queue, waiting
* if necessary up to the specified wait time, for another thread
* to insert it.
*
* @return the head of this queue, or <tt>null</tt> if the
* specified waiting time elapses before an element is present.
* @throws InterruptedException {@inheritDoc}
*/
public E poll(long timeout, TimeUnit unit) throws InterruptedException {
Object e = transferer.transfer(null, true, unit.toNanos(timeout));
if (e != null || !Thread.interrupted())
return (E)e;
throw new InterruptedException();
}
poll操作：
/**
* Retrieves and removes the head of this queue, if another thread
* is currently making an element available.
*
* @return the head of this queue, or <tt>null</tt> if no
* element is available.
*/
public E poll() {
return (E)transferer.transfer(null, true, 0);
}
是否为空
/**
* Always returns <tt>true</tt>.
* A <tt>SynchronousQueue</tt> has no internal capacity.
*
* @return <tt>true</tt>
*/
public boolean isEmpty() {
return true;
}
总是返回true，说明同步队列总是为空。
size：
/**
* Always returns zero.
* A <tt>SynchronousQueue</tt> has no internal capacity.
*
* @return zero.
*/
public int size() {
return 0;
}
remainingCapacity：
/**
* Always returns zero.
* A <tt>SynchronousQueue</tt> has no internal capacity.
*
* @return zero.
*/
public int remainingCapacity() {
return 0;
}
clear：
/**
* Does nothing.
* A <tt>SynchronousQueue</tt> has no internal capacity.
*/
public void clear() {
}
contains：
/**
* Always returns <tt>false</tt>.
* A <tt>SynchronousQueue</tt> has no internal capacity.
*
* @param o the element
* @return <tt>false</tt>
*/
public boolean contains(Object o) {
return false;
}
remove：
/**
* Always returns <tt>false</tt>.
* A <tt>SynchronousQueue</tt> has no internal capacity.
*
* @param o the element to remove
* @return <tt>false</tt>
*/
public boolean remove(Object o) {
return false;
}
/**
* Returns <tt>false</tt> unless the given collection is empty.
* A <tt>SynchronousQueue</tt> has no internal capacity.
*
* @param c the collection
* @return <tt>false</tt> unless given collection is empty
*/
public boolean containsAll(Collection<?> c) {
return c.isEmpty();
}
/**
* Always returns <tt>false</tt>.
* A <tt>SynchronousQueue</tt> has no internal capacity.
*
* @param c the collection
* @return <tt>false</tt>
*/
public boolean removeAll(Collection<?> c) {
return false;
}
/**
* Always returns <tt>false</tt>.
* A <tt>SynchronousQueue</tt> has no internal capacity.
*
* @param c the collection
* @return <tt>false</tt>
*/
public boolean retainAll(Collection<?> c) {
return false;
}
/**
* Always returns <tt>null</tt>.
* A <tt>SynchronousQueue</tt> does not return elements
* unless actively waited on.
*
* @return <tt>null</tt>
*/
public E peek() {
return null;
}
/**
* Returns an empty iterator in which <tt>hasNext</tt> always returns
* <tt>false</tt>.
*
* @return an empty iterator
*/
public Iterator<E> iterator() {
return Collections.emptyIterator();
}
从上面这些方法可以出，由于同步队列总是为空，所以size为0.剩余容量为0，peek返回false，contains返回false，remove返回false。
drainTo操作：
**
* @throws UnsupportedOperationException {@inheritDoc}
* @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
* @throws IllegalArgumentException {@inheritDoc}
*/
public int drainTo(Collection<? super E> c) {
if (c == null)
throw new NullPointerException();
if (c == this)
throw new IllegalArgumentException();
int n = 0;
E e;
while ( (e = poll()) != null) {
c.add(e);
++n;
}
return n;
}
/**
* @throws UnsupportedOperationException {@inheritDoc}
* @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
* @throws IllegalArgumentException {@inheritDoc}
*/
public int drainTo(Collection<? super E> c, int maxElements) {
if (c == null)
throw new NullPointerException();
if (c == this)
throw new IllegalArgumentException();
int n = 0;
E e;
while (n < maxElements && (e = poll()) != null) {
c.add(e);
++n;
}
return n;
}
下面再看序列化与反序列化：
/*
* To cope with serialization strategy in the 1.5 version of
* SynchronousQueue, we declare some unused classes and fields
* that exist solely to enable serializability across versions.
* These fields are never used, so are initialized only if this
* object is ever serialized or deserialized.
*/
static class WaitQueue implements java.io.Serializable { }
static class LifoWaitQueue extends WaitQueue {
private static final long serialVersionUID = -3633113410248163686L;
}
static class FifoWaitQueue extends WaitQueue {
private static final long serialVersionUID = -3623113410248163686L;
}
private ReentrantLock qlock;
private WaitQueue waitingProducers;
private WaitQueue waitingConsumers;
/**
* Save the state to a stream (that is, serialize it).
*
* @param s the stream
*/
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
boolean fair = transferer instanceof TransferQueue;
if (fair) {
qlock = new ReentrantLock(true);
waitingProducers = new FifoWaitQueue();
waitingConsumers = new FifoWaitQueue();
}
else {
qlock = new ReentrantLock();
waitingProducers = new LifoWaitQueue();
waitingConsumers = new LifoWaitQueue();
}
s.defaultWriteObject();
}
private void readObject(final java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
if (waitingProducers instanceof FifoWaitQueue)
transferer = new TransferQueue();
else
transferer = new TransferStack();
}
序列化与反序列的作用主要是判断同步队列到底是公平的，还是非公平的。
总结：
TransferQueue在执行take/put操作时，首先根据元素是否判断当前节点的模式，如果元素为null则为REQUEST（take）模式，否则为DATA模式（put）。然后自旋匹配节点，如果队列头或尾节点没有初始化，则跳出本次自旋，如果队列为空，或当前节点与队尾模式相同，自旋或阻塞直到节点被fulfilled；如果队列不为空，且与队头的模式不同，及匹配成功，出队列，如果是REQUEST操作，返回匹配到节点的元素，如果为DATA操作，返回当前节点元素。TransferQueue相对于TransferStack来说，操作匹配过程更简单，TransferStack为非公平策略下的实现LIFO，TransferQueue是公平策略下的实现FIFO。TransferQueue中的QNODE与TransferStack的SNODE节点有所不同处理后继next，等待线程，节点元素外，SNODE还有一个对应的模式REQUEST，DATA或FULFILLING，而QNODE中用一个布尔值isData来表示模式，这个模式的判断主要根据是元素是否为null，如果为null，则为REQUEST（take）模式，否则为DATA模式（put）。SynchronousQueue根据构造公平参数，确定transferer为TransferStack还是TransferQueue，默认为TransferStack，SynchronousQueue的put/offer和take/poll统一委托给transferer，即通过TransferStack和TransferQueue的transfer(Object e, boolean timed, long nanos) 方法。由于同步队列一个take伴随着一个put，反之亦然，所有队列总是为空，所以size为0.剩余容量为0，peek返回false，contains返回false，remove返回false。