队列容器

package com.bjsxt.base.coll013;

import java.util.concurrent.SynchronousQueue;


/**
ConcurrentLinkedQueue : 先进先出高并发队列。无锁、无阻塞。不允许null元素。
先进在头，后进在尾。
 方法  ：add（ ）、 offer（） 、Poll（）从头部取出元素，并删除、
       peek（）从头部取出元素，不删除。
BlockingQueue 接口：  阻塞队列
	ArrayBlockingQueue  ：  不支持并发，低效。有长度限制，并且阻塞，无读写分离（意味着生产和消费不能同时进行）
	LinkedBlockingQueue ：  支持并发操作，高效。基于链表的阻塞队列，高效的处理并发数据，无长度限制，内部实现读写分离锁，
	                                                          从而实现生产者和消费者操作完全并行运行。
	SynchronousQueue    ：  一种没有缓冲的队列，生成一个消费一个，没有第二个了。
 *
 */
public class UseQueue {

	public static void main(String[] args) throws Exception {
		
		//高性能无阻塞无界队列：ConcurrentLinkedQueue
		//先进先出高并发队列。无锁、无阻塞。不允许null元素。
/*		ConcurrentLinkedQueue<String> q = new ConcurrentLinkedQueue<String>();
		q.offer("a");
		q.offer("b");
		q.offer("c");
		q.offer("d");
		q.add("e");
		
		System.out.println(q.poll());	//a 从头部取出元素，并从队列里删除
		System.out.println(q.size());	//4
		System.out.println(q.peek());	//b   不移除，一下次peek 依然是这个b
		System.out.println(q.size());	//4
*/		
		/*ArrayBlockingQueue<String> array = new ArrayBlockingQueue<String>(5);
		array.put("a");
		array.put("b");
		array.add("c");
		array.add("d");
		array.add("e");
		array.add("f");
		System.out.println(array.offer("a", 3, TimeUnit.SECONDS));*///等待3秒，如果加入不成功就抛异常。
		
		
		
		
		//阻塞队列
		//支持并发操作，高效。基于链表的阻塞队列，高效的处理并发数据，无长度限制，内部实现读写分离锁，
        //从而实现生产者和消费者操作完全并行运行。
/*		LinkedBlockingQueue<String> q = new LinkedBlockingQueue<String>();
		q.offer("a");
		q.offer("b");
		q.offer("c");
		q.offer("d");
		q.offer("e");
		q.add("f");
		//System.out.println(q.size());
		
		for (Iterator iterator = q.iterator(); iterator.hasNext();) {
			String string = (String) iterator.next();
			System.out.println(string);
		}
		System.out.println("---------------------------------");
		List<String> list = new ArrayList<String>();
		System.out.println(q.drainTo(list, 3));
		System.out.println(list.size());
		for (String string : list) {
			System.out.println(string);
		}*/
		
		
		
		final SynchronousQueue<String> q = new SynchronousQueue<String>();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					System.out.println(q.take());
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
		t1.start();
		Thread.sleep(100);
		Thread t2 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				try {
					q.put("ddd");
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
			}
		});
		t2.start();		
	}
}