1.BlockingQueue和普通Queue的區別

  BlockingQueue阻塞佇列，多執行緒併發的上下文中，take，put，方法會發生阻塞狀態

  Queue 普通的Queue如果實現生產者，消費者的阻塞等待，需要自己實現Blocking狀態

2.ArrayBlockQueue&LinkedBlockQueue區別

  ArrayBlockQueue 陣列阻塞佇列，指定一個大小後無法擴容。put()方法中會檢測如果新增的元素會超出陣列範圍，在put()方法地方會blocking住，一直到該queue可以新增元素

  LinkedBlockQueue 連結串列阻塞佇列，不指定capacity可以無限制進行新增，put()方法不超過int.MaxVal不會發生阻塞

  相同點:

  陣列阻塞佇列和連結串列阻塞佇列，queue佇列為空的時候，再呼叫take方法會發生阻塞blocking狀態

3.ArrayBlockQueue full阻塞佇列滿的情況下測試例項

 private BlockingQueue<Integer> mQueue = new ArrayBlockingQueue<Integer>(8);

  for(int i = 0;i < 10;i++){
Thread thread = new Thread("threadName-" + i){
@Override
public void run() {
super.run();
int r = (int) (Math.random() * 100);
try {
System.out.println("tName-" + getName() + " putdata->" + r + " waiting...");
mQueue.put(r);
System.out.println("tName-" + getName() + " put succ -> " + r);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
thread.start();
}


try {
Thread.sleep(2*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}


Thread t = new Thread(){
@Override
public void run() {
super.run();
try {
Integer r = mQueue.take();
System.out.println("take data :" + r);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
t.start();

發現倒數第二行列印地方，在take發生完畢後，被阻塞的66才會put成功

輸出結果:

tName-threadName-0 putdata->83 waiting...
tName-threadName-3 putdata->12 waiting...
tName-threadName-2 putdata->27 waiting...
tName-threadName-2 put succ -> 27
tName-threadName-0 put succ -> 83
tName-threadName-6 putdata->9 waiting...
tName-threadName-6 put succ -> 9
tName-threadName-4 putdata->12 waiting...
tName-threadName-4 put succ -> 12
tName-threadName-8 putdata->2 waiting...
tName-threadName-8 put succ -> 2
tName-threadName-1 putdata->24 waiting...
tName-threadName-1 put succ -> 24
tName-threadName-9 putdata->65 waiting...
tName-threadName-9 put succ -> 65
tName-threadName-5 putdata->66 waiting...
tName-threadName-3 put succ -> 12
tName-threadName-7 putdata->82 waiting...
take data :27
tName-threadName-5 put succ -> 66

4.ArrayBlockQueue empty 阻塞佇列空的情況下測試例項

private BlockingQueue<Integer> mQueue = new ArrayBlockingQueue<Integer>(8);

//put the data into the queue
for(int i = 0;i < 6;i++){
try {
mQueue.put(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

//
for(int i = 0;i < 12;i++){
Thread thread = new Thread("thread name-" + i){
@Override
public void run() {
super.run();
try {
System.out.println( getName() + " waiting for take...");
int r = mQueue.take();
System.out.println("tName-" + getName() + " take data->" + r);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
thread.start();
}

執行緒6,2,8一直都在阻塞waiting等待佇列充資料才進行

輸出結果:

thread name-0 waiting for take...
tName-thread name-0 take data->0
thread name-1 waiting for take...
thread name-11 waiting for take...
tName-thread name-11 take data->1
thread name-7 waiting for take...
thread name-9 waiting for take...
thread name-10 waiting for take...
tName-thread name-10 take data->5
thread name-4 waiting for take...
thread name-5 waiting for take...
thread name-3 waiting for take...
tName-thread name-9 take data->4
tName-thread name-1 take data->3
tName-thread name-7 take data->2
thread name-6 waiting for take...
thread name-2 waiting for take...
thread name-8 waiting for take...

5.LinkedBlockQueue full測試

  private BlockingQueue<Integer> mQueue = new LinkedBlockingQueue<Integer>();

  for(int i = 0;i < 100;i++){
Thread thread = new Thread("tName-" + i){
@Override
public void run() {
super.run();
int r = (int) (Math.random() * 50);
System.out.println("tName-" + getName() + " put " + r + " waiting for...");
try {
mQueue.put(r);
System.out.println("tName-" + " put " + r + " succ");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
thread.start();
}

  for計數規模可擴大到1000,10000,100000

  一旦new LinkedBlockingQueue<Integer>(capacity); 指定容量大小後和ArrayBlockingQueue效果一致

6.LinkedBlockQueue empty測試例項

   private BlockingQueue<Integer> mQueue = new LinkedBlockingQueue<Integer>();

   //put data
for(int i = 0;i < 6;i++){
try {
mQueue.put(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

//take data
for(int i = 0;i < 8;i++){
Thread thread = new Thread("tName-" + i){
@Override
public void run() {
super.run();
try {
System.out.println("tName" + getName() + " take waiting...");
int r = mQueue.take();
System.out.println("tName" + getName() + " take r " + r + " succ");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
thread.start();
}

輸出結果可以看出，執行緒5和執行緒6一直block狀態，沒有發生take succ的行為。 新增6個元素，8個執行緒從佇列獲取元素。有兩個執行緒會一直髮生阻塞狀態

輸出結果:

tNametName-0 take waiting...
tNametName-3 take waiting...
tNametName-3 take r 1 succ
tNametName-2 take waiting...
tNametName-1 take waiting...
tNametName-1 take r 3 succ
tNametName-2 take r 2 succ
tNametName-4 take waiting...
tNametName-4 take r 4 succ
tNametName-0 take r 0 succ
tNametName-7 take waiting...
tNametName-6 take waiting...
tNametName-5 take waiting...
tNametName-7 take r 5 succ