package javautilconcurrent;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
/**
* 这是一个阻塞队列,其中,每个插入操作必须等待另一个线程的对应移除操作,反之亦然。
* 一个同步队列不具有任何内部容量,甚至不具有 1 的容量。
* 本质上讲,SynchronousQueue 是之前提过的 BlockingQueue 的又一实现。
* 它给我们提供了在线程之间交换单一元素的极轻量级方法,使用 ArrayBlockingQueue 使用的阻塞语义。
*/
public class SynchronousQueueTest {
public static void main(String[] args) {
BlockingQueue<String> drop = new SynchronousQueue<String>();
(new Thread(new Producer(drop))).start();
(new Thread(new Consumer(drop))).start();
}
/**
*生产者线程
*/
static class Producer implements Runnable{
private BlockingQueue<String> drop;
List<String> messages = Arrays.asList(
"Mares eat oats",
"Does eat oats",
"Little lambs eat ivy",
"Wouldn't you eat ivy too?");
public Producer(BlockingQueue<String> drop){
this.drop = drop;
}
public void run(){
try {
for(String s : messages){
System.out.println("Producer:" + System.currentTimeMillis() + " " + s);
drop.put(s);
}
drop.put("DONE");
} catch (Exception e) {
System.out.println("Producer Interrupted!");
}
}
}
/**
* 消费者线程
*/
static class Consumer implements Runnable{
private BlockingQueue<String> drop;
public Consumer(BlockingQueue<String> drop){
this.drop = drop;
}
public void run(){
try {
String msg = null;
while(!((msg = drop.take()).equals("DONE"))){
System.out.println("Consumer:" + System.currentTimeMillis() + " " + msg);
Thread.sleep(1000);
}
} catch (Exception e) {
System.out.println("Consumer Interrupted!");
}
}
}
}
结果如下:
Producer:1377436949078 Mares eat oats
Producer:1377436949078 Does eat oats
Consumer:1377436949078 Mares eat oats
Consumer:1377436950078 Does eat oats
Producer:1377436950078 Little lambs eat ivy
Consumer:1377436951078 Little lambs eat ivy
Producer:1377436951078 Wouldn't you eat ivy too?
Consumer:1377436952078 Wouldn't you eat ivy too?