java并发编程-SynchronousQueue阻塞队列

  SynchronousQueue无容量的同步队列,即入队线程通过SynchronousQueue将节点传递给出队线程,若暂时无出队线程接收,则一直等待;反之亦然。 这是一种快速传递元素的方式,也就是说在这种情况下元素总是以最快的方式从插入着(生产者)传递给移除着(消费者), 这在多任务队列中是最快处理任务的方式.

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

   竞争机制支持公平和非公平两种:非公平竞争模式使用的数据结构是后进先出栈(Lifo Stack);公平竞争模式则使用先进先出队列(Fifo Queue),性能上两者是相当的,一般情况下,Fifo通常可以支持更大的吞吐量,但Lifo可以更大程度的保持线程的本地化。 

// 无参构造
public SynchronousQueue() {
	this(false);
}
// 带fair构造
public SynchronousQueue(boolean fair) {
	transferer = fair ? new TransferQueue() : new TransferStack();
}

SynchronousQueue添加和删除元素:

public void put(E o) throws InterruptedException {
	if (o == null) throw new NullPointerException();
	if (transferer.transfer(o, false, 0) == null) {
		Thread.interrupted();
		throw new InterruptedException();
	}
}
public E take() throws InterruptedException {
	Object e = transferer.transfer(null, false, 0);
	if (e != null)
		return (E)e;
	Thread.interrupted();
	throw new InterruptedException();
}

案例:

public static void main(String[] args) throws InterruptedException {
		final SynchronousQueue<Integer> queue = new SynchronousQueue<Integer>();
		new Thread() {
			@Override
			public void run() {
				try {
					while (true) {
						System.out.println("size1:" + queue.size());
						System.out.println("element:" + queue.take());
						System.out.println("size2:" + queue.size());
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}.start();
		queue.put(1);
		queue.put(2);
		queue.put(3);
}

 

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

发表评论