阻塞式并发队列

--BlockingQueue: 阻塞式队列--可以实现生产者消费者模式
  --LinkedBQ: 链表实现
        --ArrayBQ:数组实现， 有限队列
        --DelayQueue: 执行定时任务，可以设置多长时间被消费者拿走
        --LinkedTransferQueue: 应用情形:消费者先启动，生产者生产一个东西的时候(调用transfer方法)不往
队列里面放，而是查看有没有消费者，如果有消费者就直接给消费者消费，如果这时候没有消费者就 会产生阻塞，下面的代码就不会执行了。但是还是可以调用add()等方法向容器中添加元素
--SynchronousQueue(特殊的LinkedTransferQueue): 跟LinkedTransferQueue基本一样，不同的是SynchronousQueue的容量为零，不能调用add()等方法向容器添加元素，只能调用put()方法来阻塞等待消费者消费。而LinkedTransferQueue可以向容量添加元素，也可以使用transfer()方法阻塞等待消费者消费

1.LinkedBlockingQueue

public class A {

  //阻塞式队列--可以实现生产者消费者模式
  static BlockingQueue<String> strs = new LinkedBlockingQueue<String>();
  
  public static void main(String[] args) {
    //开启一个生产者线程
    new Thread() {
      public void run() {
        for (int i = 0; i < 10; i++) {
          try {
            strs.put("a" + i);
            Thread.sleep(100);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
      }
    }.start();
    
    //开启5个消费者线程
    for (int i = 0; i < 5; i++) {
      new Thread() {
        public void run() {
          try {
            while(true){
            //使用take()方法进行消费
            System.out.println(Thread.currentThread().getName() + "消费"+strs.take());
            }
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
      }.start();
    }

  }
  
}

2.有界队列: ArrayBlockingQueue

public class B {
  
  //有界队列，这里是10个就满了
  static BlockingQueue<String> strs = new ArrayBlockingQueue<String>(10);

  public static void main(String[] args) throws InterruptedException {
    for (int i = 0; i < 10; i++) {
      strs.put("a" + i);//装了10个就装不下了
    }
    //strs.add("aa");//满了调用add()方法想要再添加就会抛出异常
    System.out.println(strs);
    //strs.put("aaa");//满了就会等待，程序阻塞,看清楚这里是阻塞，下面的代码是不会再执行了
    boolean offer = strs.offer("a");//没有添加成功返回false
    System.out.println(offer);
    System.out.println(strs);
  }

}

3.LinkedTransferQueue

public class C {
  
  public static void main(String[] args) {
    LinkedTransferQueue<String> strs = new LinkedTransferQueue();

    //如果想要使用transfer()方法就必须要先启动消费者
    new Thread() {
      public void run() {
        System.out.println(strs.take());
      }
    };
    
    //生产，这时候必须要有消费者消费掉，否则就阻塞在这里，下面的代码不会执行了
    strs.transfer("aaa");//使用该方法是不会向队列里面放东西，只要是transfer()一个东西，就必须有消费者消费
    strs.put("aa");//使用该方法就不会发生阻塞
  }
  
}

4.SynchronousQueue(特殊的LinkedTransferQueue)

public class D {

  public static void main(String[] args) throws InterruptedException {
    //该并发容器的容量为零，不能向容器里面放东西，必须马上被消费者消费掉
    final BlockingQueue<String> strs = new SynchronousQueue();
    
    //先启动消费者
    new Thread() {
      public void run() {
        while(true) {
          try {
            System.out.println(strs.take());
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
      }
    }.start();
    
    //strs.add("a");//不能调用add()方法，因为不能向容器里面放东西
    strs.put("a");//阻塞等待消费者消费,如果没有被消费，则下面的代码执行不了(被阻塞了)
    System.out.println(strs.size());//容器的容量必须时刻为零
  }
  
}