（八）java并发队列

Java并发队列

---

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

一、ConcurrentLinkedQueue

定义

ConcurrentLinkedQueue : 是一个适用于高并发场景下的队列，通过无锁的方式，实现了高并发状态下的高性能，通常ConcurrentLinkedQueue性能好于BlockingQueue。 
它是一个基于链接节点的无界线程安全队列。该队列的元素遵循先进先出的原则。 
头是最先加入的，尾是最近加入的，该队列不允许null元素。

ConcurrentLinkedQueue重要方法:

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

代码示例：

•     ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
      q.offer("张三");
      q.offer("李四");
      q.offer("王五");
      q.offer("赵六");
      q.offer("大圣");
      //从头获取元素,删除该元素
      System.out.println(q.poll());
      //从头获取元素,不刪除该元素
      System.out.println(q.peek());
      //获取总长度
      System.out.println(q.size());

二、BlockingQueue

定义： 
阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作是： 
1、在队列为空时，获取元素的线程会等待队列变为非空。 
2、当队列满时，存储元素的线程会等待队列可用。 
阻塞队列是线程安全的。 
用途： 
阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。

1、ArrayBlockingQueue

重要方法： 
具体看在线文档：jdk在线中文文档

add(E e) 
将指定的元素插入到此队列的尾部（如果立即可行且不会超过该队列的容量），在成功时返回 true，如果此队列已满，则抛出IllegalStateException； 
offer(E e) 
将指定的元素插入到此队列的尾部（如果立即可行且不会超过该队列的容量），在成功时返回 true，如果此队列已满，则返回 false。 
offer(E e, long timeout, TimeUnit unit) 
将指定的元素插入此队列的尾部，如果该队列已满，则在到达指定的等待时间之前等待可用的空间。

定义：

ArrayBlockingQueue是一个有边界的阻塞队列，它的内部实现是一个数组。 
有边界的意思是它的容量是有限的，我们必须在其初始化的时候指定它的容量大小，容量大小一旦指定就不可改变。 
ArrayBlockingQueue是以先进先出的方式存储数据，最新插入的对象是尾部，最新移出的对象是头部。

下面是一个初始化和使用ArrayBlockingQueue的例子：

• //初始化3个队列
  ArrayBlockingQueue array = new ArrayBlockingQueue(3);
          array.add("张三");
          array.add("李四");
          array.add("大圣");
          // 添加阻塞队列
          boolean a=array.offer("王五",1, TimeUnit.SECONDS);
          System.out.println(a);
          //运行结果：false

  
  
  

2、LinkedBlockingQueue

定义：

LinkedBlockingQueue阻塞队列大小的配置是可选的， 
如果我们初始化时指定一个大小，它就是有边界的，如果不指定，它就是无边界的。 
说是无边界，其实是采用了默认大小为Integer.MAX_VALUE的容量 。它的内部实现是一个链表。 
和ArrayBlockingQueue一样，LinkedBlockingQueue 也是以先进先出的方式存储数据，最新插入的对象是尾部，最新移出的对象是头部。

下面是一个初始化和使LinkedBlockingQueue的例子：

• //初始化
  LinkedBlockingQueue lbq = new LinkedBlockingQueue(3);
          lbq.add("张三");
          lbq.add("李四");
          lbq.add("李四");
          System.out.println(lbq.size());
          //运行结果：3

3、PriorityBlockingQueue

定义：

PriorityBlockingQueue是一个没有边界的队列，它的排序规则和 java.util.PriorityQueue一样。需要注意，PriorityBlockingQueue中允许插入null对象。 
所有插入PriorityBlockingQueue的对象必须实现 java.lang.Comparable接口，队列优先级的排序规则就是按照我们对这个接口的实现来定义的。 
另外，我们可以从PriorityBlockingQueue获得一个迭代器Iterator，但这个迭代器并不保证按照优先级顺序进行迭代。

4、SynchronousQueue

定义：

SynchronousQueue队列内部仅允许容纳一个元素。当一个线程插入一个元素后会被阻塞，除非这个元素被另一个线程消费。

三、使用BlockingQueue模拟生产者与消费者

代码示例

生产者：

• public class ProducerThread implements Runnable {
      private BlockingQueue queue;
      private volatile boolean flag = true;
      private static AtomicInteger count = new AtomicInteger();
  
      public ProducerThread(BlockingQueue queue) {
          this.queue = queue;
      }
  
      @Override
      public void run() {
          try {
              System.out.println("生产线程启动...");
              while (flag) {
                  System.out.println("正在生产数据....");
                  String data = count.incrementAndGet()+"";
                  // 将数据存入队列中
                  boolean offer = queue.offer(data, 2, TimeUnit.SECONDS);
                  if (offer) {
                      System.out.println("生产者,存入" + data + "到队列中,成功.");
                  } else {
                      System.out.println("生产者,存入" + data + "到队列中,失败.");
                  }
                  Thread.sleep(1000);
              }
          } catch (Exception e) {
  
          } finally {
              System.out.println("生产者退出线程");
          }
  
      }
      public void stopThread() {
          this.flag = false;
      }
  }

消费者：

• class ConsumerThread implements Runnable {
      private BlockingQueue<String> queue;
      private volatile boolean flag = true;
  
      public ConsumerThread(BlockingQueue<String> queue) {
          this.queue = queue;
  
      }
  
      @Override
      public void run() {
          System.out.println("消费线程启动...");
          try {
              while (flag) {
                  System.out.println("消费者,正在从队列中获取数据..");
                  String data = queue.poll(2, TimeUnit.SECONDS);
                  if (data != null) {
                      System.out.println("消费者,拿到队列中的数据data:" + data);
                      Thread.sleep(1000);
                  } else {
                      System.out.println("消费者,超过2秒未获取到数据..");
                      flag = false;
                  }
  
  
              }
          } catch (Exception e) {
              e.printStackTrace();
          } finally {
              System.out.println("消费者退出线程...");
          }
  
      }
  
  }

运行：

• public class ProducerAndConsumer {
      public static void main(String[] args) throws InterruptedException {
          BlockingQueue<String> queue = new LinkedBlockingQueue<String>(10);
          ProducerThread producerThread1 = new ProducerThread(queue);
          ProducerThread producerThread2 = new ProducerThread(queue);
          ConsumerThread consumerThread1 = new ConsumerThread(queue);
          Thread t1 = new Thread(producerThread1);
          Thread t2 = new Thread(producerThread2);
          Thread c1 = new Thread(consumerThread1);
          t1.start();
          t2.start();
          c1.start();
  
          // 执行2s后，生产者不再生产
          Thread.sleep(2* 1000);
          producerThread1.stopThread();
          producerThread2.stopThread();
  
      }
  }

  
  
  

运行结果：