queue是什么
隊列，是一種數據結構。除了優先級隊列和lifo隊列外，隊列都是以fifo（先進先出）的方式對各個元素進行排序的。無論使用哪種排序方式，隊列的頭都是調用remove()或poll()移除元素的。在fifo隊列中，所有新元素都插入隊列的末尾。
queue中的方法
queue中的方法不難理解，6個，每2對是一個也就是總共3對。看一下jdkapi就知道了：
注意一點就好，queue通常不允許插入null，盡管某些實現（比如linkedlist）是允許的，但是也不建議。
blockingqueue
1、blockingqueue概述
blockingqueue也是java.util.concurrent下的主要用來控制線程同步的工具。
blockingqueue有四個具體的實現類,根據不同需求,選擇不同的實現類
1、arrayblockingqueue：一個由數組支持的有界阻塞隊列，規定大小的blockingqueue,其構造函數必須帶一個int參數來指明其大小.其所含的對象是以fifo(先入先出)順序排序的。
2、linkedblockingqueue：大小不定的blockingqueue,若其構造函數帶一個規定大小的參數,生成的blockingqueue有大小限制,若不帶大小參數,所生成的blockingqueue的大小由integer.max_value來決定.其所含的對象是以fifo(先入先出)順序排序的。
3、priorityblockingqueue：類似于linkedblockqueue,但其所含對象的排序不是fifo,而是依據對象的自然排序順序或者是構造函數的comparator決定的順序。
4、synchronousqueue：特殊的blockingqueue,對其的操作必須是放和取交替完成的。
linkedblockingqueue可以指定容量，也可以不指定，不指定的話，默認最大是integer.max_value,其中主要用到put和take方法，put方法在隊列滿的時候會阻塞直到有隊列成員被消費，take方法在隊列空的時候會阻塞，直到有隊列成員被放進來。
講blockingqueue，因為blockingqueue是queue中的一個重點，并且通過blockingqueue我們再次加深對于生產者/消費者模型的理解。其他的queue都不難，通過查看jdkapi和簡單閱讀源碼完全可以理解他們的作用。
blockingqueue，顧名思義，阻塞隊列。blockingqueue是在java.util.concurrent下的，因此不難理解，blockingqueue是為了解決多線程中數據高效安全傳輸而提出的。
多線程中，很多場景都可以使用隊列實現，比如經典的生產者/消費者模型，通過隊列可以便利地實現兩者之間數據的共享，定義一個生產者線程，定義一個消費者線程，通過隊列共享數據就可以了。
當然現實不可能都是理想的，比如消費者消費速度比生產者生產的速度要快，那么消費者消費到一定程度上的時候，必須要暫停等待一下了（使消費者線程處于waiting狀態）。blockingqueue的提出，就是為了解決這個問題的，他不用程序員去控制這些細節，同時還要兼顧效率和線程安全。
阻塞隊列所謂的"阻塞"，指的是某些情況下線程會掛起（即阻塞），一旦條件滿足，被掛起的線程又會自動喚醒。使用blockingqueue，不需要關心什么時候需要阻塞線程，什么時候需要喚醒線程，這些內容blockingqueue都已經做好了
2、blockingqueue中的方法
blockingqueue既然是queue的子接口，必然有queue中的方法，上面已經列了。看一下blockingqueue中特有的方法：
（1）voidput(ee)throwsinterruptedexception
把e添加進blockingqueue中，如果blockingqueue中沒有空間，則調用線程被阻塞，進入等待狀態，直到blockingqueue中有空間再繼續
（2）voidtake()throwsinterruptedexception
取走blockingqueue里面排在首位的對象，如果blockingqueue為空，則調用線程被阻塞，進入等待狀態，直到blockingqueue有新的數據被加入
（3）intdrainto(collection<?supere>c,intmaxelements)
一次性取走blockingqueue中的數據到c中，可以指定取的個數。通過該方法可以提升獲取數據效率，不需要多次分批加鎖或釋放鎖
3、arrayblockingqueue
基于數組的阻塞隊列，必須指定隊列大小。比較簡單。arrayblockingqueue中只有一個reentrantlock對象，這意味著生產者和消費者無法并行運行（見下面的代碼）。另外，創建arrayblockingqueue時，可以指定reentrantlock是否為公平鎖，默認采用非公平鎖。
|
1
2
3
4
5
6
|
/** main lock guarding all access */private final reentrantlock lock;/** condition for waiting takes */private final condition notempty;/** condition for waiting puts */private final condition notfull; |
4、linkedblockingqueue
基于鏈表的阻塞隊列，和arrayblockingqueue差不多。不過linkedblockingqueue如果不指定隊列容量大小，會默認一個類似無限大小的容量，之所以說是類似是因為這個無限大小是integer.max_value，這么說就好理解arrayblockingqueue為什么必須要制定大小了，如果arrayblockingqueue不指定大小的話就用integer.max_value，那將造成大量的空間浪費，但是基于鏈表實現就不一樣的，一個一個節點連起來而已。另外，linkedblockingqueue生產者和消費者都有自己的鎖（見下面的代碼），這意味著生產者和消費者可以"同時"運行。
|
1
2
3
4
5
6
7
8
|
/** lock held by take, poll, etc */private final reentrantlock takelock = new reentrantlock();/** wait queue for waiting takes */private final condition notempty = takelock.newcondition();/** lock held by put, offer, etc */private final reentrantlock putlock = new reentrantlock();/** wait queue for waiting puts */private final condition notfull = putlock.newcondition(); |
5、synchronousqueue
比較特殊，一種沒有緩沖的等待隊列。什么叫做沒有緩沖區，arrayblocking中有：
|
1
2
|
/** the queued items */private final e[] items; |
數組用以存儲隊列。linkedblockingqueue中有：
|
1
2
3
4
5
6
7
8
9
|
/** * linked list node class */static class node<e> { /** the item, volatile to ensure barrier separating write and read */ volatile e item; node<e> next; node(e x) { item = x; }} |
將隊列以鏈表形式連接。
生產者/消費者操作數據實際上都是通過這兩個"中介"來操作數據的，但是synchronousqueue則是生產者直接把數據給消費者（消費者直接從生產者這里拿數據），好像又回到了沒有生產者/消費者模型的老辦法了。換句話說，每一個插入操作必須等待一個線程對應的移除操作。synchronousqueue又有兩種模式：
1、公平模式
采用公平鎖，并配合一個fifo隊列（queue）來管理多余的生產者和消費者
2、非公平模式
采用非公平鎖，并配合一個lifo棧（stack）來管理多余的生產者和消費者，這也是synchronousqueue默認的模式
利用blockingqueue實現生產者消費者模型
上一篇我們寫的生產者消費者模型有局限，局限體現在：
緩沖區內只能存放一個數據，實際生產者/消費者模型中的緩沖區內可以存放大量生產者生產出來的數據
生產者和消費者處理數據的速度幾乎一樣
ok，我們就用blockingqueue來簡單寫一個例子，并且讓生產者、消費者處理數據速度不同。子類選擇的是arrayblockingqueue，大小定為10：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
public static void main(string[] args){ final blockingqueue<string> bq = new arrayblockingqueue<string>(10); runnable producerrunnable = new runnable() { int i = 0; public void run() { while (true) { try { system.out.println("我生產了一個" + i++); bq.put(i + ""); thread.sleep(1000); } catch (interruptedexception e) { e.printstacktrace(); } } } }; runnable customerrunnable = new runnable() { public void run() { while (true) { try { system.out.println("我消費了一個" + bq.take()); thread.sleep(3000); } catch (interruptedexception e) { e.printstacktrace(); } } } }; thread producerthread = new thread(producerrunnable); thread customerthread = new thread(customerrunnable); producerthread.start(); customerthread.start();} |
代碼的做法是讓生產者生產速度快于消費者消費速度的，看一下運行結果：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
我生產了一個0我消費了一個1我生產了一個1我生產了一個2我消費了一個2我生產了一個3我生產了一個4我生產了一個5我消費了一個3我生產了一個6我生產了一個7我生產了一個8我消費了一個4我生產了一個9我生產了一個10我生產了一個11我消費了一個5我生產了一個12我生產了一個13我生產了一個14我消費了一個6我生產了一個15我生產了一個16我消費了一個7我生產了一個17我消費了一個8我生產了一個18 |
分兩部分來看輸出結果：
1、第1行~第23行。這塊blockingqueue未滿，所以生產者隨便生產，消費者隨便消費，基本上都是生產3個消費1個，消費者消費速度慢
2、第24行~第27行，從前面我們可以看出，生產到16，消費到6，說明到了arrayblockingqueue的極限10了，這時候沒辦法，生產者生產一個arrayblockingqueue就滿了，所以不能繼續生產了，只有等到消費者消費完才可以繼續生產。所以之后的打印內容一定是一個生產者、一個消費者
這就是前面一章開頭說的"通過平衡生產者和消費者的處理能力來提高整體處理數據的速度"，這給例子應該體現得很明顯。另外，也不要擔心非單一生產者/消費者場景下的系統假死問題，緩沖區空、緩沖區滿的場景blockingqueue都是定義了不同的condition，所以不會喚醒自己的同類。
總結
以上就是本文關于java多線程queue、blockingqueue和使用blockingqueue實現生產消費者模型方法解析的全部內容，希望對大家有所幫助。如有不足之處，歡迎留言指出。
原文鏈接：https://www.cnblogs.com/xrq730/p/4855857.html
