java queue 公平策略_并发编程（十）—— Java 并发队列 BlockingQueue 实现之 SynchronousQueue源码分析...

BlockingQueue 实现之 SynchronousQueue

SynchronousQueue是一个没有数据缓冲的BlockingQueue，生产者线程对其的插入操作put必须等待消费者的移除操作take，反过来也一样。

不像ArrayBlockingQueue或LinkedListBlockingQueue，SynchronousQueue内部并没有数据缓存空间，你不能调用peek()方法来看队列中是否有数据元素，因为数据元素只有当你试着取走的时候才可能存在，不取走而只想偷窥一下是不行的，当然遍历这个队列的操作也是不允许的。队列头元素是第一个排队要插入数据的线程，而不是要交换的数据。数据是在配对的生产者和消费者线程之间直接传递的，并不会将数据缓冲数据到队列中。可以这样来理解：生产者和消费者互相等待对方，握手，然后一起离开。

SynchronousQueue的一个使用场景是在线程池里。Executors.newCachedThreadPool()就使用了SynchronousQueue，这个线程池根据需要(新任务到来时)创建新的线程，如果有空闲线程则会重复使用，线程空闲了60秒后会被回收。

接下来，我们来看看具体的源码实现吧，它的源码不是很简单的那种，我们需要先搞清楚它的设计思想。

我们先看大框架：

1 //构造时，我们可以指定公平模式还是非公平模式，本文主要讲解公平模式

2 public SynchronousQueue(booleanfair) {3 transferer = fair ? new TransferQueue() : newTransferStack();4 }5 abstract static classTransferer {6 //从方法名上大概就知道，这个方法用于转移元素，从生产者手上转到消费者手上7 //也可以被动地，消费者调用这个方法来从生产者手上取元素8 //第一个参数 e 如果不是 null，代表场景为：将元素从生产者转移给消费者9 //如果是 null，代表消费者等待生产者提供元素，然后返回值就是相应的生产者提供的元素10 //第二个参数代表是否设置超时，如果设置超时，超时时间是第三个参数的值11 //返回值如果是 null，代表超时，或者中断。具体是哪个，可以通过检测中断状态得到。

12 abstract Object transfer(Object e, boolean timed, longnanos);13 }14

15 TransferQueue() {16 //初始化时，head和tail都是空节点

17 QNode h = new QNode(null, false); //initialize to dummy node.

18 head =h;19 tail =h;20 }

Transferer 有两个内部实现类，是因为构造 SynchronousQueue 的时候，我们可以指定公平策略。公平模式意味着，所有的读写线程都遵守先来后到，FIFO 嘛，对应 TransferQueue。而非公平模式则对应 TransferStack。

本文我们主要看公平模式源码，接下来，我们看看 put 方法和 take 方法：

1 //写入值

2 public void put(E o) throwsInterruptedException {3 if (o == null) throw newNullPointerException();4 if (transferer.transfer(o, false, 0) == null) { //1

5 Thread.interrupted();6 throw newInterruptedException();7 }8 }9 //读取值并移除

10 public E take() throwsInterruptedException {11 Object e = transferer.transfer(null, false, 0); //2

12 if (e != null)13 return(E)e;14 Thread.interrupted();15 throw newInterruptedException();16 }

我们看到，写操作 put(E o) 和读操作 take() 都是调用 Transferer.transfer(…) 方法，区别在于第一个参数是否为 null 值。

我们来看看 transfer 的设计思路，其基本算法如下：

当调用这个方法时，如果队列是空的，或者队列中的节点和当前的线程操作类型一致(如当前操作是 put 操作，而队列中的元素也都是写线程)。这种情况下，将当前线程加入到等待队列并阻塞线程。

如果队列中有等待节点，而且与当前操作可以匹配(1、如队列中都是读操作线程，当前线程是写操作线程；2、如队列中都是写操作线程，当前线程是读操作；)。这种情况下，匹配等待队列的队头，出队，返回相应数据。

其实这里有个隐含的条件被满足了，队列如果不为空，肯定都是同种类型的节点，要么都是读操作，要么都是写操作。这个就要看到底是读线程积压了，还是写线程积压了。

我们可以假设出一个男女配对的场景：

1、一个男的过来，如果一个人都没有，那么他需要等待；如果发现有一堆男的在等待，那么他需要排到队列后面；如果发现是一堆女的在排队，那么他直接牵走队头的那个女的；

2、相反一个女的过来，如果一个人都没有，那么她需要等待；如果发现有一堆女的在等待，那么她需要排到队列后面；如果发现是一堆男的在排队，那么队头的那个男的直接出队牵走这个女的；

既然这里说到了等待队列，我们先看看其实现，也就是 QNode:

1 static final classQNode {2 volatile QNode next; //可以看出来，等待队列是单向链表

3 volatile Object item; //CAS'ed to or from null

4 volatile Thread waiter; //将线程对象保存在这里，用于挂起和唤醒

5 final boolean isData; //用于判断是写线程节点(isData == true)，还是读线程节点

6

7 QNode(Object item, booleanisData) {8 this.item =item;9 this.isData =isData;10 }11 ......

我们再来看 transfer 方法的代码：

1 /**

2 * Puts or takes an item.3 */

4 Object transfer(Object e, boolean timed, longnanos) {5

6 QNode s = null; //constructed/reused as needed

7 boolean isData = (e != null);8

9 for(;;) {10 QNode t =tail;11 QNode h =head;12 if (t == null || h == null) //saw uninitialized value13 //说明还没有初始化，则跳出继续循环，直至初始化完成

14 continue; //spin15

16 //走到这里，说明已经初始化完成，但是初始化时head = h;tail = h;head和tail都是相同的空节点17 //如果h == t为false，则判断t.isData == isData，判断队尾节点和当前节点类型是否一致18 //队列空，或队列中节点类型和当前节点一致，19 //即我们说的第一种情况，将节点入队即可。读者要想着这块 if 里面方法其实就是入队

20 if (h == t || t.isData == isData) { //empty or same-mode

21 QNode tn =t.next;22 //t != tail 说明刚刚有节点入队，continue 即可

23 if (t != tail) //inconsistent read

24 continue;25 //有其他节点入队，但是 tail 还是指向原来的，此时设置 tail 即可

26 if (tn != null) { //lagging tail27 //这个方法就是：如果 tail 此时为 t 的话，设置为 tn

28 advanceTail(t, tn);29 continue;30 }31 //

32 if (timed && nanos <= 0) //can't wait

33 return null;34 //s == null，则创建一个新节点

35 if (s == null)36 s = newQNode(e, isData);37 //将当前节点，插入到 tail 的后面

38 if (!t.casNext(null, s)) //failed to link in

39 continue;40

41 //将当前节点设置为新的 tail

42 advanceTail(t, s); //swing tail and wait43 //看到这里，请读者先往下滑到这个方法，看完了以后再回来这里，思路也就不会断了

44 Object x =awaitFulfill(s, e, timed, nanos);45 //到这里，说明之前入队的线程被唤醒了，准备往下执行46 //若返回的x == s表示，当前线程已经超时或者中断，不然的话s == null或者是匹配的节点

47 if (x == s) { //wait was cancelled

48 clean(t, s);49 return null;50 }51 //若s节点被设置为取消

52 if (!s.isOffList()) { //not already unlinked

53 advanceHead(t, s); //unlink if head

54 if (x != null) //and forget fields

55 s.item =s;56 s.waiter = null;57 }58 return (x != null) ?x : e;59

60 //这里的 else 分支就是上面说的第二种情况，有相应的读或写相匹配的情况

61 } else { //complementary-mode

62 QNode m = h.next; //node to fulfill63 //不一致读，表明有其他线程修改了队列

64 if (t != tail || m == null || h !=head)65 continue; //inconsistent read

66

67 Object x =m.item;68 if (isData == (x != null) || //m already fulfilled

69 x == m || //m cancelled

70 !m.casItem(x, e)) { //lost CAS

71 advanceHead(h, m); //dequeue and retry

72 continue;73 }74

75 advanceHead(h, m); //successfully fulfilled

76 LockSupport.unpark(m.waiter);77 return (x != null) ?x : e;78 }79 }80 }81

82 voidadvanceTail(QNode t, QNode nt) {83 if (tail ==t)84 UNSAFE.compareAndSwapObject(this, tailOffset, t, nt);85 }

注意44行e为即将要挂起线程的node的值，如果是put，则为其传的值，如果是get，则是null。

1 //自旋或阻塞，直到满足条件，这个方法返回

2 Object awaitFulfill(QNode s, Object e, boolean timed, longnanos) {3

4 long lastTime = timed ? System.nanoTime() : 0;5 Thread w =Thread.currentThread();6 //判断需要自旋的次数，

7 int spins = ((head.next == s) ?

8 (timed ? maxTimedSpins : maxUntimedSpins) : 0);9 for(;;) {10 //如果被中断了，那么取消这个节点

11 if(w.isInterrupted())12 //就是将当前节点 s 中的 item 属性设置为 this

13 s.tryCancel(e);14 Object x =s.item;15 //这里是这个方法的唯一的出口

16 if (x !=e)17 returnx;18 //如果需要，检测是否超时

19 if(timed) {20 long now =System.nanoTime();21 nanos -= now -lastTime;22 lastTime =now;23 if (nanos <= 0) {24 s.tryCancel(e);25 continue;26 }27 }28 if (spins > 0)29 --spins;30 //如果自旋达到了最大的次数，那么检测

31 else if (s.waiter == null)32 s.waiter =w;33 //如果自旋到了最大的次数，或者没有设置超时，那么线程挂起，等待唤醒

34 else if (!timed)35 //挂起当前线程

36 LockSupport.park(this);37 else if (nanos >spinForTimeoutThreshold)38 LockSupport.parkNanos(this, nanos);39 }40 }41

42 voidtryCancel(Object cmp) {43 //将节点item设置为自己，代表此节点取消排队

44 UNSAFE.compareAndSwapObject(this, itemOffset, cmp, this);45 }

我们看第14行，上面我们已经说过第44行e为即将要挂起线程的node的值，如果是put，则为其传的值，如果是get，则是null。则如果队列里都是相同的操作类型，会直接挂起，再看上上个方法的第二个else分支，也就是不同的操作类型的时候，会直接获取队列的第一个等待节点，并且第70行，通过cas设置其节点的item为本次操作的值，也就是如果本次操作为put，则队列的节点为take类型，也就是队列节点的item值为null，现在通过cas设置其值，然后再将其唤醒，则awaitFulfill唤醒后，第17行处节点的值已经被cas更改了，自然不能和原始的e相等，就会直接返回给take。

现在我们来按照实际情况来走一遍流程：

1、线程1初始化 new SynchronousQueue(true) ，调用put(E o)写入值，我们看transfer(Object e, boolean timed, long nanos)方法第7行，isData 为true,接在到第20行，因为是刚刚初始化，tail和head都为空节点，36行新建一个节点，38行将当前节点，插入到 tail 的后面,42行将当前节点设置为新的 tail，所以队列中有三个节点，两个是空节点，一个是当前节点，我们再看到 awaitFulfill(QNode s, Object e, boolean timed, long nanos)方法第16行，此时x = e，不返回，36行处挂起当前线程。

此时线程2调用 take()取值，我们看transfer(Object e, boolean timed, long nanos)方法第7行，isData 为false,接在到第20行，tail和head不相同，之前线程1写入时，QNode 的isData 为true,所以 if (h == t || t.isData == isData) 不满足，进入到transfer的62行，取到头节点的后面一个节点，很明显，这个节点的item是null,68行处x != null为false,  isData == (x != null) 为true,则执行71行将头节点后移一位，相当于去除了头结点，跳出循环继续；这一次循环第62行取到的是线程1中添加的节点，x != null为true,isData == (x != null)为false,x == m 为false,执行 m.casItem(x, e) ，此时e为null,将线程1中添加的节点的item的值设置为null,此时成功，不执行72行处，我们可以看到75行处，将头结点后移一位，相当于线程一put进去的值被移除了，76行处唤醒线程1，刚才说过这次循环62行取到的是线程1中添加的节点，68行处x为线程一中添加的元素，77行 return (x != null) ? x : e;  x != null 为true，则retrue x，此时take()拿到了线程1中添加的元素，并唤醒线程1，将线程一添加的节点去除，take()方法结束。我们再来看看线程1被唤醒后，看 awaitFulfill 方法中第36行，被唤醒后接着for循环，第14行获取被挂起之前添加的节点中的item,可是上面讲的线程2中m.casItem(x, e) 已经将此节点的e设置为null ,则17行处retrue null，再到transfer 方法44行处，X为null,58行处返回e,put方法结束。

2、线程1初始化 new SynchronousQueue(true) ，调用 take() 取值，我们看transfer(Object e, boolean timed, long nanos)方法第7行，isData 为false,，因为是刚刚初始化，tail和head都为空节点，36行新建一个节点，38行将当前节点，插入到 tail 的后面,42行将当前节点设置为新的 tail，所以队列中有三个节点，两个是空节点，一个是当前节点，我们再看到 awaitFulfill(QNode s, Object e, boolean timed, long nanos)方法第16行，此时x = e =null，不返回，36行处挂起当前线程。

此时线程2调用 put(E o)写入值，我们看transfer(Object e, boolean timed, long nanos)方法第7行，isData 为true,接在到第20行，tail和head不相同，之前线程1取值时，QNode 的isData 为false,所以 if (h == t || t.isData == isData) 不满足，进入到transfer的62行，取到头节点的后面一个节点，很明显，这个节点的item是null,68行处x != null为false,  isData == (x != null) 为true,则执行71行将头节点后移一位，相当于去除了头结点，跳出循环继续；这一次循环第62行取到的是线程1中等待取值的节点，x != null为false,isData == (x != null)为false,x == m 为false,执行 m.casItem(x, e) ，将线程1中take()的节点的item的值设置为e,此时成功，不执行72行处，我们可以看到75行处，将头结点后移一位，相当于线程1取到值后就将线程从等待队列中移除了，76行处唤醒线程1，刚才说过这次循环62行取到的是线程1中等待取值的节点，68行处x为null，77行 return (x != null) ? x : e;  x != null 为false，则 retrue e，此时put()方法给线程1的QNode设置了item为e，并唤醒线程1，将线程一添加的节点去除，take()方法结束。我们再来看看线程1被唤醒后，看 awaitFulfill 方法中第36行，被唤醒后接着for循环，第14行获取被挂起之前添加的节点中的item,可是上面讲的线程2 put() 中m.casItem(x, e) 已经将此节点的e设置为 e ,则17行处retrue 的值为put()的 e ，再到transfer 方法44行处，X为e,58行处返回X,也就是put()的e ,take方法结束。

我们再来看看offer()和poll()

1 public booleanoffer(E e) {2 if (e == null) throw newNullPointerException();3 return transferer.transfer(e, true, 0) != null;4 }

我们可以看出，也是调用了 transfer 方法，如果队列为空了，第一次offer添加元素的话，transfer第32行，timed =true,nanos =0,则此时reture null;

1 public E poll(long timeout, TimeUnit unit) throwsInterruptedException {2 E e = transferer.transfer(null, true, unit.toNanos(timeout));3 if (e != null || !Thread.interrupted())4 returne;5 throw newInterruptedException();6 }

带超时的poll，如果队列为空，则会添加到等待队列，并且阻塞，经过 timeout 还没有拿到元素，则超时返回false,拿到了元素则返回元素。

由此可见，只有线程在等待着取元素， offer(E e) 才有可能成功，如果没有线程等待着取，则一定会返回失败。

总结

1、线程做相同类型的操作：

多个线程 take()，则将线程包装成QNode节点，item为null，将节点添加到队列，将线程挂起；

多个线程 put()，将线程包装成QNode节点，item为 e，将节点添加到队列，将线程挂起。

2、线程做不同类型的操作：

有线程先做了put()，其他线程做take()操作时，take取到队列中的第一个等待节点中的item，take返回item,并将第一个等待节点唤醒，put返回e；

有线程先做了take() ,其他线程put()操作时，put将元素e赋值给队列中第一个等待节点的item，put返回e,并将第一个等待节点唤醒，take返回e。