10.BockingQueue

它是一个队列，支持阻塞机制，阻塞的放入和得到数据。

常用方法：

Offer(anObject):表示如果有可能，将anObject加到队列中，如果可以容纳，则返回true,否则返回false,(本方法不阻塞当前执行线程的方法)。

Put(anObject):把anObject添加到队列中，如果队列没有空间，调用方法的线程被阻塞，直到队列有空间再加入。

Poll(time):取走队列中排在首位的对象，若取不出，可以等time规定的时间，取不到时返回null.

Take():取走队列中排在首位的对象，如果队列为空，调用方法的线程被阻塞，直到队列有新元素在取出。

DrainTo（）:一次从队列中取出所有元素，可以提升效率，不用分配取元素。

模拟linkedBlockingQueue的put和take方法

Put:把object添加到BlockingQueue里，如果BlockingQueue没有空间，则调用此方法的线程被阻断，直到BlockingQueue里面有空间在继续。

Take:取走BlockingQueue里排在首位的对象，若BolckingQueue为空，阻断进入阻塞状态，直到BlockingQueue加入新的元素。

public class MyQueue {

  

   //1 需要一个承装元素的集合

   private LinkedList<Object> list = new LinkedList<Object>();

  

   //2 需要一个计数器

   private AtomicInteger count = new AtomicInteger(0);

  

   //3 需要制定上限和下限

   private final int minSize = 0;

  

   private final int maxSize ;

  

   //4 构造方法

   public MyQueue(int size){

      this.maxSize = size;

   }

  

   //5 初始化一个对象 用于加锁

   private final Object lock = new Object();

  

  

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

   public void put(Object obj){

      synchronized (lock) {

         while(count.get() == this.maxSize){

            try {

                lock.wait();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

         }

         //1 加入元素

         list.add(obj);

         //2 计数器累加

         count.incrementAndGet();

         //3 通知另外一个线程（唤醒）

         lock.notify();

         System.out.println("新加入的元素为:" + obj);

      }

   }

  

  

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

   public Object take(){

      Object ret = null;

      synchronized (lock) {

         while(count.get() == this.minSize){

            try {

                lock.wait();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

         }

         //1 做移除元素操作

         ret = list.removeFirst();

         //2 计数器递减

         count.decrementAndGet();

         //3 唤醒另外一个线程

         lock.notify();

      }

      return ret;

   }

  

   public int getSize(){

      return this.count.get();

   }

  

  

   public static void main(String[] args) {

     

      final MyQueue mq = new MyQueue(5);

      mq.put("a");

      mq.put("b");

      mq.put("c");

      mq.put("d");

      mq.put("e");

     

      System.out.println("当前容器的长度:" + mq.getSize());

     

      Thread t1 = new Thread(new Runnable() {

         @Override

         public void run() {

            mq.put("f");

            mq.put("g");

         }

      },"t1");

     

      t1.start();

     

     

      Thread t2 = new Thread(new Runnable() {

         @Override

         public void run() {

            Object o1 = mq.take();

            System.out.println("移除的元素为:" + o1);

            Object o2 = mq.take();

            System.out.println("移除的元素为:" + o2);

         }

      },"t2");

     

     

      try {

         TimeUnit.SECONDS.sleep(2);

      } catch (InterruptedException e) {

         e.printStackTrace();

      }

     

      t2.start();

     

     

   }

  

  

  

}

输出结果：

新加入的元素为:a

新加入的元素为:b

新加入的元素为:c

新加入的元素为:d

新加入的元素为:e

当前容器的长度:5

移除的元素为:a

新加入的元素为:f

移除的元素为:b

1. 新加入的元素为:g