public class ArrayBlockingQueue<E> extends AbstractQueue<E>
implements BlockingQueue<E>, java.io.Serializable {
 /** 隊列元素 */
 final Object[] items;

 /** 下一次讀取操作的位置, poll, peek or remove */
 int takeIndex;

 /** 下一次寫入操作的位置, offer, or add */
 int putIndex;

 /** 元素數(shù)量 */
 int count;
 
 /*
  * Concurrency control uses the classic two-condition algorithm
  * found in any textbook.
  * 它采用一個 ReentrantLock 和相應(yīng)的兩個 Condition 來實現(xiàn)。
  */

 /** Main lock guarding all access */
 final ReentrantLock lock;

 /** Condition for waiting takes */
 private final Condition notEmpty;

 /** Condition for waiting puts */
 private final Condition notFull;
 
 /** 指定大小 */
 public ArrayBlockingQueue(int capacity) {
  this(capacity, false);
 }
 
 /** 
  * 指定容量大小與指定訪問策略 
  * @param fair 指定獨占鎖是公平鎖還是非公平鎖。非公平鎖的吞吐量比較高，公平鎖可以保證每次都是等待最久的線程獲取到鎖；
  */
 public ArrayBlockingQueue(int capacity, boolean fair) {}
 
 /** 
  * 指定容量大小、指定訪問策略與最初包含給定集合中的元素 
  * @param c 將此集合中的元素在構(gòu)造方法期間就先添加到隊列中 
  */
 public ArrayBlockingQueue(int capacity, boolean fair,
        Collection<? extends E> c) {}
}

/** 進(jìn)行入隊操作 */
public void put(E e) throws InterruptedException {
  //e為null，則拋出NullPointerException異常
  checkNotNull(e);
  //獲取獨占鎖
  final ReentrantLock lock = this.lock;
  /**
   * lockInterruptibly()
   * 獲取鎖定，除非當(dāng)前線程為interrupted
   * 如果鎖沒有被另一個線程占用并且立即返回，則將鎖定計數(shù)設(shè)置為1。
   * 如果當(dāng)前線程已經(jīng)保存此鎖，則保持計數(shù)將遞增1，該方法立即返回。
   * 如果鎖被另一個線程保持，則當(dāng)前線程將被禁用以進(jìn)行線程調(diào)度，并且處于休眠狀態(tài)
   * 
   */
  lock.lockInterruptibly();
  try {
   //空隊列
   while (count == items.length)
    //進(jìn)行條件等待處理
    notFull.await();
   //入隊操作
   enqueue(e);
  } finally {
   //釋放鎖
   lock.unlock();
  }
 }
 
 /** 真正的入隊 */
 private void enqueue(E x) {
  // assert lock.getHoldCount() == 1;
  // assert items[putIndex] == null;
  //獲取當(dāng)前元素
  final Object[] items = this.items;
  //按下一個插入索引進(jìn)行元素添加
  items[putIndex] = x;
  // 計算下一個元素應(yīng)該存放的下標(biāo)，可以理解為循環(huán)隊列
  if (++putIndex == items.length)
   putIndex = 0;
  count++;
  //喚起消費者
  notEmpty.signal();
}

public E take() throws InterruptedException {
  final ReentrantLock lock = this.lock;
  lock.lockInterruptibly();
  try {
   while (count == 0)
    notEmpty.await();
   return dequeue();
  } finally {
   lock.unlock();
  }
 }
 private E dequeue() {
  // assert lock.getHoldCount() == 1;
  // assert items[takeIndex] != null;
  final Object[] items = this.items;
  @SuppressWarnings("unchecked")
  E x = (E) items[takeIndex];
  items[takeIndex] = null;
  if (++takeIndex == items.length)
   takeIndex = 0;
  count--;
  //這里有些特殊
  if (itrs != null)
   //保持隊列中的元素和迭代器的元素一致
   itrs.elementDequeued();
  notFull.signal();
  return x;
}

//該類的迭代器，所有的迭代器共享數(shù)據(jù)，隊列改變會影響所有的迭代器

transient Itrs itrs = null; //其存放了目前所創(chuàng)建的所有迭代器。

/**
* 迭代器和它們的隊列之間的共享數(shù)據(jù)，允許隊列元素被刪除時更新迭代器的修改。
*/
class Itrs {
  void elementDequeued() {
   // assert lock.getHoldCount() == 1;
   if (count == 0)
    //隊列中數(shù)量為0的時候，隊列就是空的，會將所有迭代器進(jìn)行清理并移除
    queueIsEmpty();
   //takeIndex的下標(biāo)是0，意味著隊列從尾中取完了，又回到頭部獲取
   else if (takeIndex == 0)
    takeIndexWrapped();
  }
  
  /**
   * 當(dāng)隊列為空的時候做的事情
   * 1. 通知所有迭代器隊列已經(jīng)為空
   * 2. 清空所有的弱引用，并且將迭代器置空
   */
  void queueIsEmpty() {}
  
  /**
   * 將takeIndex包裝成0
   * 并且通知所有的迭代器，并且刪除已經(jīng)過期的任何對象（個人理解是置空對象）
   * 也直接的說就是在Blocking隊列進(jìn)行出隊的時候，進(jìn)行迭代器中的數(shù)據(jù)同步，保持隊列中的元素和迭代器的元素是一致的。
   */
  void takeIndexWrapped() {}
}

//從這里知道，在ArrayBlockingQueue對象中調(diào)用此方法，才會生成這個對象
//那么就可以理解為，只要并未調(diào)用此方法，則ArrayBlockingQueue對象中的Itrs對象則為空
public Iterator<E> iterator() {
  return new Itr();
 }
 
 private class Itr implements Iterator<E> {
  Itr() {
   //這里就是生產(chǎn)它的地方
   //count等于0的時候，創(chuàng)建的這個迭代器是個無用的迭代器，可以直接移除，進(jìn)入detach模式。
   //否則就把當(dāng)前隊列的讀取位置給迭代器當(dāng)做下一個元素，cursor存儲下個元素的位置。
   if (count == 0) {
    // assert itrs == null;
    cursor = NONE;
    nextIndex = NONE;
    prevTakeIndex = DETACHED;
   } else {
    final int takeIndex = ArrayBlockingQueue.this.takeIndex;
    prevTakeIndex = takeIndex;
    nextItem = itemAt(nextIndex = takeIndex);
    cursor = incCursor(takeIndex);
    if (itrs == null) {
     itrs = new Itrs(this);
    } else {
     itrs.register(this); // in this order
     itrs.doSomeSweeping(false);
    }
    prevCycles = itrs.cycles;
    // assert takeIndex >= 0;
    // assert prevTakeIndex == takeIndex;
    // assert nextIndex >= 0;
    // assert nextItem != null;
    }
  }
}

package com.rumenz.task;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @className: BlockingQuqueExample
 * @description: TODO 類描述
 * @author: mac
 * @date: 2021/1/20
 **/
public class BlockingQueueExample {

 private static volatile Boolean flag=false;

 public static void main(String[] args) {

 

  BlockingQueue blockingQueue=new ArrayBlockingQueue(1024);
  ExecutorService executorService = Executors.newFixedThreadPool(2);

  executorService.execute(()->{
    try{
     blockingQueue.put(1);
     Thread.sleep(2000);
     blockingQueue.put(3);
     flag=true;
    }catch (Exception e){
     e.printStackTrace();
    }
  });

  executorService.execute(()->{
   try {

    while (!flag){
     Integer i = (Integer) blockingQueue.take();
     System.out.println(i);
    }

   }catch (Exception e){
    e.printStackTrace();
   }

  });

  executorService.shutdown();
 }
}

public class LinkedBlockingQueue<E> extends AbstractQueue<E>
implements BlockingQueue<E>, java.io.Serializable {
 //隊列的容量，指定大小或為默認(rèn)值Integer.MAX_VALUE
 private final int capacity;
 
 //元素的數(shù)量
 private final AtomicInteger count = new AtomicInteger();
 
 //隊列頭節(jié)點，始終滿足head.item==null
 transient Node<E> head;
 
 //隊列的尾節(jié)點，始終滿足last.next==null
 private transient Node<E> last;
 
 /** Lock held by take, poll, etc */
 //出隊的鎖：take, poll, peek 等讀操作的方法需要獲取到這個鎖
 private final ReentrantLock takeLock = new ReentrantLock();

 /** Wait queue for waiting takes */
 //當(dāng)隊列為空時，保存執(zhí)行出隊的線程：如果讀操作的時候隊列是空的，那么等待 notEmpty 條件
 private final Condition notEmpty = takeLock.newCondition();

 /** Lock held by put, offer, etc */
 //入隊的鎖：put, offer 等寫操作的方法需要獲取到這個鎖
 private final ReentrantLock putLock = new ReentrantLock();

 /** Wait queue for waiting puts */
 //當(dāng)隊列滿時，保存執(zhí)行入隊的線程：如果寫操作的時候隊列是滿的，那么等待 notFull 條件
 private final Condition notFull = putLock.newCondition();
 
 //傳說中的無界隊列
 public LinkedBlockingQueue() {}
 //傳說中的有界隊列
 public LinkedBlockingQueue(int capacity) {
  if (capacity <= 0) throw new IllegalArgumentException();
  this.capacity = capacity;
  last = head = new Node<E>(null);
 }
 //傳說中的無界隊列
 public LinkedBlockingQueue(Collection<? extends E> c){}
 
 /**
  * 鏈表節(jié)點類
  */
 static class Node<E> {
  E item;

  /**
   * One of:
   * - 真正的繼任者節(jié)點
   * - 這個節(jié)點，意味著繼任者是head.next
   * - 空，意味著沒有后繼者（這是最后一個節(jié)點）
   */
  Node<E> next;

  Node(E x) { item = x; }
 }
}

public class LinkedBlockingQueue<E> extends AbstractQueue<E>
  implements BlockingQueue<E>, java.io.Serializable { 
 /**
  * 將指定元素插入到此隊列的尾部，如有必要，則等待空間變得可用。
  */
 public void put(E e) throws InterruptedException {
  if (e == null) throw new NullPointerException();
  // 如果你糾結(jié)這里為什么是 -1，可以看看 offer 方法。這就是個標(biāo)識成功、失敗的標(biāo)志而已。
  int c = -1;
  //包裝成node節(jié)點
  Node<E> node = new Node<E>(e);
  final ReentrantLock putLock = this.putLock;
  final AtomicInteger count = this.count;
  //獲取鎖定
  putLock.lockInterruptibly();
  try {
   /** 如果隊列滿，等待 notFull 的條件滿足。 */
   while (count.get() == capacity) {
    notFull.await();
   }
   //入隊
   enqueue(node);
   //原子性自增
   c = count.getAndIncrement();
   // 如果這個元素入隊后，還有至少一個槽可以使用，調(diào)用 notFull.signal() 喚醒等待線程。
   // 哪些線程會等待在 notFull 這個 Condition 上呢？
   if (c + 1 < capacity)
    notFull.signal();
  } finally {
  //解鎖
   putLock.unlock();
  }
  // 如果 c == 0，那么代表隊列在這個元素入隊前是空的（不包括head空節(jié)點），
  // 那么所有的讀線程都在等待 notEmpty 這個條件，等待喚醒，這里做一次喚醒操作
  if (c == 0)
   signalNotEmpty();
 }
 
 /** 鏈接節(jié)點在隊列末尾 */
 private void enqueue(Node<E> node) {
  // assert putLock.isHeldByCurrentThread();
  // assert last.next == null;
  // 入隊的代碼非常簡單，就是將 last 屬性指向這個新元素，并且讓原隊尾的 next 指向這個元素
  //last.next = node;
  //last = node;
  // 這里入隊沒有并發(fā)問題，因為只有獲取到 putLock 獨占鎖以后，才可以進(jìn)行此操作
  last = last.next = node;
 }
 
 /**
  * 等待PUT信號
  * 僅在 take/poll 中調(diào)用
  * 也就是說：元素入隊后，如果需要，則會調(diào)用這個方法喚醒讀線程來讀
  */
 private void signalNotFull() {
  final ReentrantLock putLock = this.putLock;
  putLock.lock();
  try {
   notFull.signal();//喚醒
  } finally {
   putLock.unlock();
  }
 }
}

public class LinkedBlockingQueue<E> extends AbstractQueue<E>
  implements BlockingQueue<E>, java.io.Serializable { 
 public E take() throws InterruptedException {
  E x;
  int c = -1;
  final AtomicInteger count = this.count;
  final ReentrantLock takeLock = this.takeLock;
  //首先，需要獲取到 takeLock 才能進(jìn)行出隊操作
  takeLock.lockInterruptibly();
  try {
   // 如果隊列為空，等待 notEmpty 這個條件滿足再繼續(xù)執(zhí)行
   while (count.get() == 0) {
    notEmpty.await();
   }
   //// 出隊
   x = dequeue();
   //count 進(jìn)行原子減 1
   c = count.getAndDecrement();
   // 如果這次出隊后，隊列中至少還有一個元素，那么調(diào)用 notEmpty.signal() 喚醒其他的讀線程
   if (c > 1)
    notEmpty.signal();
  } finally {
   takeLock.unlock();
  }
  if (c == capacity)
   signalNotFull();
  return x;
 }
 
 /**
  * 出隊
  */
 private E dequeue() {
  // assert takeLock.isHeldByCurrentThread();
  // assert head.item == null;
  Node<E> h = head;
  Node<E> first = h.next;
  h.next = h; // help GC
  head = first;
  E x = first.item;
  first.item = null;
  return x;
 }
 
 /**
  * Signals a waiting put. Called only from take/poll.
  */
 private void signalNotFull() {
  final ReentrantLock putLock = this.putLock;
  putLock.lock();
  try {
   notFull.signal();
  } finally {
   putLock.unlock();
  }
 }
}

package concurrent;
import java.io.File;
import java.io.FileFilter;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;

public class TestBlockingQueue {
 static long randomTime() {
 return (long) (Math.random() * 1000);
 }

 public static void main(String[] args) {
 // 能容納100個文件
 final BlockingQueue<File> queue = new LinkedBlockingQueue<File>(100);
 // 線程池
 final ExecutorService exec = Executors.newFixedThreadPool(5);
 final File root = new File("F:\\JavaLib");
 // 完成標(biāo)志
 final File exitFile = new File("");
 // 讀個數(shù)
 final AtomicInteger rc = new AtomicInteger();
 // 寫個數(shù)
 final AtomicInteger wc = new AtomicInteger();
 // 讀線程
 Runnable read = new Runnable() {
  public void run() {
  scanFile(root);
  scanFile(exitFile);
  }

  public void scanFile(File file) {
  if (file.isDirectory()) {
   File[] files = file.listFiles(new FileFilter() {
   public boolean accept(File pathname) {
    return pathname.isDirectory()
     || pathname.getPath().endsWith(".java");
   }
   });
   for (File one : files)
   scanFile(one);
  } else {
   try {
   int index = rc.incrementAndGet();
   System.out.println("Read0: " + index + " "
    + file.getPath());
   queue.put(file);
   } catch (InterruptedException e) {
   }
  }
  }
 };
 exec.submit(read);
 // 四個寫線程
 for (int index = 0; index < 4; index++) {
  // write thread
  final int NO = index;
  Runnable write = new Runnable() {
  String threadName = "Write" + NO;
  public void run() {
   while (true) {
   try {
    Thread.sleep(randomTime());
    int index = wc.incrementAndGet();
    File file = queue.take();
    // 隊列已經(jīng)無對象
    if (file == exitFile) {
    // 再次添加"標(biāo)志"，以讓其他線程正常退出
    queue.put(exitFile);
    break;
    }
    System.out.println(threadName + ": " + index + " "
     + file.getPath());
   } catch (InterruptedException e) {
   }
   }
  }
  };
  exec.submit(write);
 }
 exec.shutdown();
 }
}