SynchronousQueue应用
SynchronousQueue是无界的,是一种无缓冲的等待队列,但是由于该Queue本身的特性,在某次添加元素后必须等待其他线程取走后才能继续添加;可以认为SynchronousQueue是一个缓存值为1的阻塞队列,但是 isEmpty()方法永远返回是true,remainingCapacity() 方法永远返回是0,remove()和removeAll() 方法永远返回是false,iterator()方法永远返回空,peek()方法永远返回null。
声明一个SynchronousQueue有两种不同的方式,它们之间有着不太一样的行为。
公平模式和非公平模式的区别:如果采用公平模式:SynchronousQueue会采用公平锁,并配合一个FIFO队列来阻塞多余的生产者和消费者,从而体系整体的公平策略;
但如果是非公平模式(SynchronousQueue默认):SynchronousQueue采用非公平锁,同时配合一个LIFO队列来管理多余的生产者和消费者,而后一种模式,如果生产者和消费者的处理速度有差距,则很容易出现饥渴的情况,即可能有某些生产者或者是消费者的数据永远都得不到处理。
=======================================================================================
SynchronousQueue是这样 一种阻塞队列,其中每个 put 必须等待一个 take,反之亦然。同步队列没有任何内部容量,甚至连一个队列的容量都没有。
不能在同步队列上进行 peek,因为仅在试图要取得元素时,该元素才存在;
除非另一个线程试图移除某个元素,否则也不能(使用任何方法)添加元素;
也不能迭代队列,因为其中没有元素可用于迭代。队列的头是尝试添加到队列中的首个已排队线程元素; 如果没有已排队线程,则不添加元素并且头为 null。
注意1:它一种阻塞队列,其中每个 put 必须等待一个 take,反之亦然。 同步队列没有任何内部容量,甚至连一个队列的容量都没有。 注意2:它是线程安全的,是阻塞的。 注意3:不允许使用 null 元素。 注意4:公平排序策略是指调用put的线程之间,或take的线程之间。 公平排序策略可以查考ArrayBlockingQueue中的公平策略。 注意5:SynchronousQueue的以下方法很有趣: * iterator() 永远返回空,因为里面没东西。 * peek() 永远返回null。 * put() 往queue放进去一个element以后就一直wait直到有其他thread进来把这个element取走。 * offer() 往queue里放一个element后立即返回,如果碰巧这个element被另一个thread取走了,offer方法返回true,认为offer成功;否则返回false。 * offer(2000, TimeUnit.SECONDS) 往queue里放一个element但是等待指定的时间后才返回,返回的逻辑和offer()方法一样。 * take() 取出并且remove掉queue里的element(认为是在queue里的。。。),取不到东西他会一直等。 * poll() 取出并且remove掉queue里的element(认为是在queue里的。。。),只有到碰巧另外一个线程正在往queue里offer数据或者put数据的时候,该方法才会取到东西。否则立即返回null。 * poll(2000, TimeUnit.SECONDS) 等待指定的时间然后取出并且remove掉queue里的element,其实就是再等其他的thread来往里塞。 * isEmpty()永远是true。 * remainingCapacity() 永远是0。 * remove()和removeAll() 永远是false。
Demo:
简化版:
import java.util.Random; import java.util.concurrent.SynchronousQueue; import java.util.concurrent.TimeUnit; public class Main { public static void main(String[] args) throws InterruptedException { SynchronousQueue<Integer> queue = new SynchronousQueue<Integer>(); new Customer(queue).start(); new Product(queue).start(); } static class Product extends Thread{ SynchronousQueue<Integer> queue; public Product(SynchronousQueue<Integer> queue){ this.queue = queue; } @Override public void run(){ while(true){ int rand = new Random().nextInt(1000); System.out.println("生产了一个产品:"+rand); System.out.println("等待三秒后运送出去..."); try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); } queue.offer(rand); System.out.println("产品生成完成:"+rand); } } } static class Customer extends Thread{ SynchronousQueue<Integer> queue; public Customer(SynchronousQueue<Integer> queue){ this.queue = queue; } @Override public void run(){ while(true){ try { System.out.println("消费了一个产品:"+queue.take()); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("------------------------------------------"); } } } }
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
生产了一个产品:326 等待三秒后运送出去... 产品生成完成:326 生产了一个产品:291 等待三秒后运送出去... 消费了一个产品:326 ------------------------------------------ 产品生成完成:291 消费了一个产品:291 ------------------------------------------ 生产了一个产品:913 等待三秒后运送出去... 产品生成完成:913 消费了一个产品:913 ------------------------------------------ 生产了一个产品:993 等待三秒后运送出去... 产品生成完成:993 消费了一个产品:993 ------------------------------------------ 生产了一个产品:295 等待三秒后运送出去... 产品生成完成:295 消费了一个产品:295 ------------------------------------------ 生产了一个产品:772 等待三秒后运送出去... 产品生成完成:772 消费了一个产品:772 ------------------------------------------ 生产了一个产品:977 等待三秒后运送出去... 产品生成完成:977 消费了一个产品:977 ------------------------------------------ 生产了一个产品:182 等待三秒后运送出去... 产品生成完成:182 消费了一个产品:182 ------------------------------------------ 生产了一个产品:606 等待三秒后运送出去... 产品生成完成:606 消费了一个产品:606 ------------------------------------------ 生产了一个产品:704 等待三秒后运送出去... 产品生成完成:704 消费了一个产品:704 ------------------------------------------ 生产了一个产品:194 等待三秒后运送出去... 产品生成完成:194 生产了一个产品:355 等待三秒后运送出去... 消费了一个产品:194 ------------------------------------------ 产品生成完成:355 消费了一个产品:355 ------------------------------------------ 生产了一个产品:991 等待三秒后运送出去... 产品生成完成:991 消费了一个产品:991 ------------------------------------------ 生产了一个产品:958 等待三秒后运送出去... 产品生成完成:958 消费了一个产品:958 ------------------------------------------ 生产了一个产品:388 等待三秒后运送出去..
从结果中可以看出如果已经生产但是还未消费的,那么会阻塞在生产一直等到消费才能生成下一个。
多线程版本:
import java.util.Random; import java.util.concurrent.SynchronousQueue; import java.util.concurrent.TimeUnit; public class Main { public static void main(String[] args) throws InterruptedException { SynchronousQueue<String> queue=new SynchronousQueue(); // TODO Auto-generated method stub for(int i=0;i<5;i++) new Thread(new ThreadProducer(queue)).start(); for(int i=0;i<5;i++) new Thread(new ThreadConsumer(queue)).start(); } } class ThreadProducer implements Runnable { ThreadProducer(SynchronousQueue<String> queue) { this.queue=queue; } SynchronousQueue<String> queue; static int cnt=0; public void run() { String name=""; int val=0; Random random =new Random(System.currentTimeMillis()); for(int i=0;i<2;i++){ cnt=(cnt+1)&0xFFFFFFFF; try{ val=random.nextInt()%15; if(val<5) { name="offer name:"+cnt; queue.offer(name); } else if(val<10) { name="put name:"+cnt; queue.put(name); } else { name="offer wait time and name:"+cnt; queue.offer(name, 1000, TimeUnit.MILLISECONDS); } Thread.sleep(1); }catch(InterruptedException e) { e.printStackTrace(); } } } } class ThreadConsumer implements Runnable { ThreadConsumer(SynchronousQueue<String> queue) { this.queue = queue; } SynchronousQueue<String> queue; public void run() { String name; for(int i=0;i<2;i++){ try { name = queue.take(); System.out.println("take " + name); Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } } } }
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
take offer wait time and name:4 take offer wait time and name:4 take offer wait time and name:5 take offer wait time and name:4 take offer wait time and name:4 take offer name:9
结果有很多种可能性,要自己尝试运行。
http://blog.csdn.net/hudashi/article/details/7076814