8.并发编程--多线程通信-wait-notify-模拟Queue

并发编程--多线程通信-wait-notify-模拟Queue

1. BlockingQueue

顾名思义，首先是一个队列，其次支持阻塞的机制；阻塞放入和获取队列中的数据。
如何实现这样一个队列：
要实现比如LinkedBlockQueue 下面两个简单的方法 put和take
put(Object obj):把一个Object放入到BlockingQueue里：如果BlockingQueue没有空间，则调用此方法的线程被阻塞，直到BlockingQueue里面有空间再继续；
take()：获取BlockingQueue队里中排在首位的数据，如果BlockingQueue没有数据，为空，或此方法阻塞，直到BlockingQueue有新的数据进入；
示例：

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

  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();


      }
  }