【BlockingQueue】ArrayBlockingQueu

ArrayBlockingQueue
基于数组实现的有界队列，put()和take()方法为阻塞方法，内部使用ReentryLock方法实现
常用方法：
add()：
内部调用了offer()方法，如果队列满，则Queue full异常
offer():
如果队列满则返回false，不继续添加
put():
内部用Condition实现，如果队列满，则notFullCondition.await()等待唤醒
take():
队列中为空则阻塞，删除队列头部元素并返回
poll():
非阻塞，队列为空则返回null,否则删除头部队列并返回元素
peek():
返回队列头部元素，并不删除

LinkedBlockingQueue
1.内部有两把锁，putLock+takeLock，提高的吞吐率
基于链表实现，默认capacity=Integer.MAX_VAlUE;
常用方法：
offer()：
1.如果队列size>=capacity，则直接返回false
2.队列不满则直接将对象封装成node入队，然后再判断队列是否满，不满的唤醒添加线程，notFull.singal()
3.当c(=count. getAndIncrement())==0时，说明有消费线程等待，需要唤醒notEmtpy.singal()，需要对takeLock进行加锁

public boolean offer(E e) {
     //添加元素为null直接抛出异常
     if (e == null) throw new NullPointerException();
      //获取队列的个数
      final AtomicInteger count = this.count;
      //判断队列是否已满
      if (count.get() == capacity)
          return false;
      int c = -1;
      //构建节点
      Node<E> node = new Node<E>(e);
      final ReentrantLock putLock = this.putLock;
      putLock.lock();
      try {
          //再次判断队列是否已满，考虑并发情况
          if (count.get() < capacity) {
              enqueue(node);//添加元素
              c = count.getAndIncrement();//拿到当前未添加新元素时的队列长度
              //如果容量还没满
              if (c + 1 < capacity)
                  notFull.signal();//唤醒下一个添加线程，执行添加操作
          }
      } finally {
          putLock.unlock();
      }
      // 由于存在添加锁和消费锁，而消费锁和添加锁都会持续唤醒等到线程，因此count肯定会变化。
      //这里的if条件表示如果队列中还有1条数据
      if (c == 0) 
        signalNotEmpty();//如果还存在数据那么就唤醒消费锁
    return c >= 0; // 添加成功返回true，否则返回false
  }

//入队操作
private void enqueue(Node<E> node) {
     //队列尾节点指向新的node节点
     last = last.next = node;
}

//signalNotEmpty方法
private void signalNotEmpty() {
      final ReentrantLock takeLock = this.takeLock;
      takeLock.lock();
          //唤醒获取并删除元素的线程
          notEmpty.signal();
      } finally {
          takeLock.unlock();
      }
  }

add()：
add方法内部调用了offer()方法，如果队列满，则报"queue full"异常
put()：
1.获取putLock锁，如果队列已满，则等待，否则入队
2.再次判断队列大小，如果没满，则唤醒添加线程notFull.singal()
3.判断c(=count.getAndIncrement())是否==0，如果是，表明可能有消费线程等待，需要唤醒notEmpty.singal()，需要获取takeLock锁

public void put(E e) throws InterruptedException {
        if (e == null) throw new NullPointerException();
        int c = -1;
        Node<E> node = new Node<E>(e);
        final ReentrantLock putLock = this.putLock;
        final AtomicInteger count = this.count;
        putLock.lockInterruptibly();
        try {
            while (count.get() == capacity) {
                notFull.await();
            }
            enqueue(node);
            c = count.getAndIncrement();
            if (c + 1 < capacity)
                notFull.signal();
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            signalNotEmpty();
    }
    private void signalNotEmpty() {
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lock();
        try {
            notEmpty.signal();
        } finally {
            takeLock.unlock();
        }
    }

取数据方法：
poll()：
1.如果没有数据，则返回null，如果有则返回数据
2.如果队列的大小c大于1，则唤醒notEmpty消费线程
3.如果c==capacity，表示notFull上等待有添加线程，需要唤醒，这点与前面分析if(c==0)是一样的道理。因为只有可能队列满了，notFull条件对象上才可能存在等待的添加线程
take()方法：
1.take是可阻塞、可中断的移除方法，如果队列为空，则notEmpty.await()
2.如果队列不为空(c>1)，则唤醒notEmpty.singal()，唤醒其他等待的消费线程
3.if(c==capacit)表明可能有添加线程等待在notFull上，需要唤醒notFull.singal()【需要对putLock加锁】
remove()方法：
1.需要对putLock和takeLock同时加锁

public E take() throws InterruptedException {
        E x;
        int c = -1;
        //获取当前队列大小
        final AtomicInteger count = this.count;
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lockInterruptibly();//可中断
        try {
            //如果队列没有数据，挂机当前线程到条件对象的等待队列中
            while (count.get() == 0) {
                notEmpty.await();
            }
            //如果存在数据直接删除并返回该数据
            x = dequeue();
            c = count.getAndDecrement();//队列大小减1
            if (c > 1)
                notEmpty.signal();//还有数据就唤醒后续的消费线程
        } finally {
            takeLock.unlock();
        }
        //满足条件，唤醒条件对象上等待队列中的添加线程
        if (c == capacity)
            signalNotFull();
        return x;
    }

public E poll() {
         //获取当前队列的大小
        final AtomicInteger count = this.count;
        if (count.get() == 0)//如果没有元素直接返回null
            return null;
        E x = null;
        int c = -1;
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lock();
        try {
            //判断队列是否有数据
            if (count.get() > 0) {
                //如果有，直接删除并获取该元素值
                x = dequeue();
                //当前队列大小减一
                c = count.getAndDecrement();
                //如果队列未空，继续唤醒等待在条件对象notEmpty上的消费线程
                if (c > 1)
                    notEmpty.signal();
            }
        } finally {
            takeLock.unlock();
        }
        //判断c是否等于capacity，这是因为如果满说明NotFull条件对象上
        //可能存在等待的添加线程
        if (c == capacity)
            signalNotFull();
        return x;
    }
  private E dequeue() {
        Node<E> h = head;//获取头结点
        Node<E> first = h.next; 获取头结的下一个节点（要删除的节点）
        h.next = h; // help GC//自己next指向自己，即被删除
        head = first;//更新头结点
        E x = first.item;//获取删除节点的值
        first.item = null;//清空数据，因为first变成头结点是不能带数据的，这样也就删除队列的带数据的第一个节点
        return x;
    }

LinkedBlockingQueue和ArrayBlockingQueue迥异
1.array和linked两种队列大小不一样，array在构建时必须指定队列大小，而linked可以指定队列大小，如果没有指定，默认为integer.max_value
2.代码实现不同，array内部使用了一把ReentryLock，linked采用锁分离，使用了两把锁，putLock和takeLock，在高并发场景下，可以并行的对队列进行操作，提高了吞吐率
3.linked当添加线程快于消费线程时，会造成内存溢出等问题
4.由于ArrayBlockingQueue采用的是数组的存储容器，因此在插入或删除元素时不会产生或销毁任何额外的对象实例，而LinkedBlockingQueue则会生成一个额外的Node对象。这可能在长时间内需要高效并发地处理大批量数据的时，对于GC可能存在较大影响。

【参考博客】
https://blog.csdn.net/javazejian/article/details/77410889?locationNum=1&fps=1