并发编程（四）------并发quene

在并发队列上JDK提供了两套实现，一个是以ConcurrentLinkedQueue为代表的高性能队列，一个是以BlockingQueue接口为代表的阻塞队列，无论哪种都继承自Queue接口！

ConcurrentLinkedQueue：

　　是一个适用于高并发场景下的队列，通过无锁的方式，实现了高并发状态下的高性能，通常ConcurrentLinkedQueue性能好于BlockingQueue。它是一个基于链接节点的无界线程安全队列。

　　该队列的元素遵循先进先出的原则，头是最先加入的，尾是最近加入的，该队列不允许null元素。

ConcurrentLinkedQueue重要方法：
add() 和 offer() 都是加入元素的方法 （在ConcurrentLinkedQueue中，这俩个方法没有任何区别）
poll() 和 peek() 都是取头元素节点，区别在于前者会删除元素，后者不会。

BlockingQueue：

BlockingQueue接口的重要方法

offer(anObject): 表示如果可能的话, 将anObject加到BlockingQueue里,即如果BlockingQueue可以容纳, 则返回true, 否则返回false.（本方法不阻塞当前执行方法的线程）

offer(E o, long timeout, TimeUnit unit), 可以设定等待的时间，如果在指定的时间内，还不能往队列中加入BlockingQueue，则返回失败。

put(anObject): 把anObject加到BlockingQueue里, 如果BlockQueue没有空间, 则调用此方法的线程被阻断直到BlockingQueue里面有空间再继续.

poll(long timeout, TimeUnit unit)：从BlockingQueue取出一个队首的对象，如果在指定时间内，队列一旦有数据可取，则立即返回队列中的数据。否则知道时间超时还没有数据可取，返回失败。

take(): 取走BlockingQueue里排在首位的对象,若BlockingQueue为空,阻断进入等待状态直到BlockingQueue有新的数据被加入;

drainTo(): 一次性从BlockingQueue获取所有可用的数据对象（还可以指定获取数据的个数），通过该方法，可以提升获取数据效率；不需要多次分批加锁或释放锁。

MyQueueTest

 package com.bfxy.thread.cord.collection;

 public class MyQueueTest {

     public static void main(String[] args) throws InterruptedException {
         MyQueue mq = new MyQueue(5);
         mq.put("a");
         mq.put("b");
         mq.put("c");
         mq.put("d");
         mq.put("e");

         System.err.println("当前元素的个数"+mq.size());

         Thread t1 = new Thread(new Runnable() {

             @Override
             public void run() {
                 mq.put("f");
                 mq.put("g");

             }
         },"t1");

         Thread.sleep(1000);

         Thread t2 = new Thread(new Runnable() {

             @Override
             public void run() {
                 try {
                     Thread.sleep(1000);
                     Object o1=mq.take();
                     Thread.sleep(1000);
                     Object o2=mq.take();
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }

             }
         },"t2");

         t1.start();
         Thread.sleep(1000);
         t2.start();
         Thread.sleep(5000);

         System.err.println(mq.getQueueList().toString());
     }

 }

MyQueue

 package com.bfxy.thread.cord.collection;

 import java.util.LinkedList;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;

 public class MyQueue {
     //1 就是我们整个队列的容器
     private final LinkedList<Object> list =new LinkedList<>();

     //2计数器
     private final AtomicInteger count = new AtomicInteger();

     private final int maxSize; //最大容量限制

     private final int minSize = 0;

     private final Object lock = new Object(); //锁

     public  MyQueue(int maxSize) {
         this.maxSize = maxSize;
     }

     public void put(Object obj) {
         synchronized (lock) {
             while (count.get() ==this.maxSize) {
                 try {
                     lock.wait();
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
             }
             //添加新的元素进到容器里
             list.add(obj);
             count.getAndIncrement();//i++
             System.err.println("元素"+obj+"已经添加容器中");
             //进行唤醒可能正在等待的take方法操作中的线程
             lock.notify();

         }

     }

     public Object take() {
         Object temp= null;
         synchronized (lock) {
             while (count.get() ==this.minSize) {
                 try {
                     lock.wait();
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
             }
             temp=list.removeFirst();
             count.getAndDecrement();//i--
             System.err.println("元素"+temp+"已经从容器中取走");
             //进行唤醒可能正在等待的put方法操作中的线程
             lock.notify();

         }

         return temp;
     }

     public int size() {
         return count.get();
     }

     public List<Object> getQueueList() {
         return list;
     }

 }