Java并发包中的同步队列SynchronousQueue实现原理

最新推荐文章于 2025-05-26 09:06:19 发布

原创最新推荐文章于 2025-05-26 09:06:19 发布 · 230 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

技术总结

JVM

面试

本文详细介绍了Java6并发编程包中的SynchronousQueue特性、实现原理及应用场景，包括阻塞算法、信号量实现和Java5、Java6的优化实现方式。重点阐述了SynchronousQueue作为无数据缓冲的BlockingQueue，在线程池和数据流控制中的高效应用。

介绍

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

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

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

实现原理

同步队列的实现方法有许多：

阻塞算法实现

阻塞算法实现通常在内部采用一个锁来保证多个线程中的put()和take()方法是串行执行的。采用锁的开销是比较大的，还会存在一种情况是线程A持有线程B需要的锁，B必须一直等待A释放锁，即使A可能一段时间内因为B的优先级比较高而得不到时间片运行。所以在高性能的应用中我们常常希望规避锁的使用。

publicclassNativeSynchronousQueue<E>{
boolean putting =false;
E item =null;
publicsynchronized E take()throwsInterruptedException{
while(item ==null)
wait();
E e = item;
item =null;
notifyAll();
return e;
}
publicsynchronizedvoid put(E e)throwsInterruptedException{
if(e==null)return;
while(putting)
wait();
putting =true;
item = e;
notifyAll();
while(item!=null)
wait();
putting =false;
notifyAll();
}
}

信号量实现

经典同步队列实现采用了三个信号量，代码很简单，比较容易理解：

publicclassSemaphoreSynchronousQueue<E>{
E item =null;
Semaphore sync =newSemaphore(0);
Semaphore send =newSemaphore(1);
Semaphore recv =newSemaphore(0);
public E take()throwsInterruptedException{
recv.acquire();
E x = item;
sync.release();
send.release();
return x;
}
publicvoid put (E x)throwsInterruptedException{
send.acquire();
item = x;
recv.release();
sync.acquire();
}
}

在多核机器上，上面方法的同步代价仍然较高，操作系统调度器需要上千个时间片来阻塞或唤醒线程，而上面的实现即使在生产者put()时已经有一个消费者在等待的情况下，阻塞和唤醒的调用仍然需要。

Java 5实现

publicclassJava5SynchronousQueue<E>{
ReentrantLock qlock =newReentrantLock();
Queue waitingProducers =newQueue();
Queue waitingConsumers =newQueue();
staticclassNodeextendsAbstractQueuedSynchronizer{
E item;
Nodenext;
Node(Object x){ item = x;}
void waitForTake(){/* (uses AQS) */}
E waitForPut(){/* (uses AQS) */}
}
public E take(){
Node node;
boolean mustWait;
qlock.lock();
node = waitingProducers.pop();
if(mustWait =(node ==null))
node = waitingConsumers.push(null);
qlock.unlock();
if(mustWait)
return node.waitForPut();
else
return node.item;
}
publicvoid put(E e){
Node node;
boolean mustWait;
qlock.lock();
node = waitingConsumers.pop();
if(mustWait =(node ==null))
node = waitingProducers.push(e);
qlock.unlock();
if(mustWait)
node.waitForTake();
else
node.item = e;
}
}

Java 5的实现相对来说做了一些优化，只使用了一个锁，使用队列代替信号量也可以允许发布者直接发布数据，而不是要首先从阻塞在信号量处被唤醒。

Java6实现

Java 6的SynchronousQueue的实现采用了一种性能更好的无锁算法 – 扩展的“Dual stack and Dual queue”算法。性能比Java5的实现有较大提升。竞争机制支持公平和非公平两种：非公平竞争模式使用的数据结构是后进先出栈(Lifo Stack)；公平竞争模式则使用先进先出队列（Fifo Queue），性能上两者是相当的，一般情况下，Fifo通常可以支持更大的吞吐量，但Lifo可以更大程度的保持线程的本地化。

代码实现里的Dual Queue或Stack内部是用链表(LinkedList)来实现的，其节点状态为以下三种情况：