Java併發工具包java.util.concurrent使用者指南
阿新 • • 發佈：2019-01-11
| 拋異常 | 特定值 | 阻塞 | 超時 | |
|---|---|---|---|---|
| 插入 | add(o) | offer(o) | put(o) | offer(o, timeout, timeunit) |
| 移除 | remove(o) | poll(o) | take(o) | poll(timeout, timeunit) |
| 檢查 | element(o) | peek(o) |
四組不同的行為方式解釋：
拋異常：如果試圖的操作無法立即執行，拋一個異常。特定值：如果試圖的操作無法立即執行，返回一個特定的值(常常是 true / false)。阻塞：如果試圖的操作無法立即執行，該方法呼叫將會發生阻塞，直到能夠執行。超時
可以訪問到 BlockingQueue 中的所有元素，而不僅僅是開始和結束的元素。比如說，你將一個物件放入佇列之中以等待處理，但你的應用想要將其取消掉。那麼你可以呼叫諸如 remove(o) 方法來將佇列之中的特定物件進行移除。但是這麼幹效率並不高(譯者注：基於佇列的資料結構，獲取除開始或結束位置的其他物件的效率不會太高)，因此你儘量不要用這一類的方法，除非你確實不得不那麼做。
BlockingQueue 的實現
ArrayBlockingQueueDelayQueueLinkedBlockingQueuePriorityBlockingQueueSynchronousQueue
Java 中使用 BlockingQueue 的例子
這裡是一個 Java 中使用 BlockingQueue 的示例。本示例使用的是 BlockingQueue 介面的 ArrayBlockingQueue 實現。首先，BlockingQueueExample 類分別在兩個獨立的執行緒中啟動了一個 Producer 和 一個 Consumer。Producer 向一個共享的 BlockingQueue 中注入字串，而 Consumer 則會從中把它們拿出來。
01.public
class BlockingQueueExample {
02.
03.public
static void
main(String[] args) throws
Exception {
04.
05.BlockingQueue queue =
new ArrayBlockingQueue(1024);
06.
07.Producer producer =
new Producer(queue);
08.Consumer consumer =
new Consumer(queue);
09.
10.new
Thread(producer).start();
11.new
Thread(consumer).start();
12.
13.Thread.sleep(4000);
14.}
15.}
以下是 Producer 類。注意它在每次 put() 呼叫時是如何休眠一秒鐘的。這將導致 Consumer 在等待佇列中物件的時候發生阻塞。
01.public
class Producer implements
Runnable{
02.
03.protected
BlockingQueue queue = null;
04.
05.public
Producer(BlockingQueue queue) {
06.this.queue = queue;
07.}
08.
09.public
void run() {
10.try
{
11.queue.put("1");
12.Thread.sleep(1000);
13.queue.put("2");
14.Thread.sleep(1000);
15.queue.put("3");
16.}
catch (InterruptedException e) {
17.e.printStackTrace();
18.}
19.}
20.}
以下是 Consumer 類。它只是把物件從佇列中抽取出來，然後將它們列印到 System.out。
01.public
class Consumer implements
Runnable{
02.
03.protected
BlockingQueue queue = null;
04.
05.public
Consumer(BlockingQueue queue) {
06.this.queue = queue;
07.}
08.
09.public
void run() {
10.try
{
11.System.out.println(queue.take());
12.System.out.println(queue.take());
13.System.out.println(queue.take());
14.}
catch (InterruptedException e) {
15.e.printStackTrace();
16.}
17.}
18.}
3. 陣列阻塞佇列 ArrayBlockingQueue
ArrayBlockingQueue 類實現了 BlockingQueue 介面。ArrayBlockingQueue 是一個有界的阻塞佇列，其內部實現是將物件放到一個數組裡。有界也就意味著，它不能夠儲存無限多數量的元素。它有一個同一時間能夠儲存元素數量的上限。你可以在對其初始化的時候設定這個上限，但之後就無法對這個上限進行修改了(譯者注：因為它是基於陣列實現的，也就具有陣列的特性：一旦初始化，大小就無法修改)。
ArrayBlockingQueue 內部以 FIFO(先進先出)的順序對元素進行儲存。佇列中的頭元素在所有元素之中是放入時間最久的那個，而尾元素則是最短的那個。
以下是在使用 ArrayBlockingQueue 的時候對其初始化的一個示例：
1.BlockingQueue queue =
new ArrayBlockingQueue(1024);
2.
3.queue.put("1");
4.
5.Object object = queue.take();
以下是使用了 Java 泛型的一個 BlockingQueue 示例。注意其中是如何對 String 元素放入和提取的：
1.BlockingQueue<String> queue =
new ArrayBlockingQueue<String>(1024);
2.
3.queue.put("1");
4.
5.String string = queue.take();
4. 延遲佇列 DelayQueue
DelayQueue 實現了 BlockingQueue 介面。DelayQueue 對元素進行持有直到一個特定的延遲到期。注入其中的元素必須實現 java.util.concurrent.Delayed 介面，該介面定義：
1.public
interface Delayed extends
Comparable<Delayed< {
2.
3.public
long getDelay(TimeUnit timeUnit);
4.
5.}
DelayQueue 將會在每個元素的 getDelay() 方法返回的值的時間段之後才釋放掉該元素。如果返回的是 0 或者負值，延遲將被認為過期，該元素將會在 DelayQueue 的下一次 take 被呼叫的時候被釋放掉。
傳遞給 getDelay 方法的 getDelay 例項是一個列舉型別，它表明了將要延遲的時間段。TimeUnit 列舉將會取以下值：
1.DAYS
2.HOURS
3.MINUTES
4.SECONDS
5.MILLISECONDS
6.MICROSECONDS
7.NANOSECONDS
正如你所看到的，Delayed 介面也繼承了 java.lang.Comparable 介面，這也就意味著 Delayed 物件之間可以進行對比。這個可能在對 DelayQueue 佇列中的元素進行排序時有用，因此它們可以根據過期時間進行有序釋放。
以下是使用 DelayQueue 的例子：
01.public
class DelayQueueExample {
02.
03.public
static void
main(String[] args) {
04.DelayQueue queue =
new DelayQueue();
05.
06.Delayed element1 =
new DelayedElement();
07.
08.queue.put(element1);
09.
10.Delayed element2 = queue.take();
11.}
12.}
DelayedElement 是我所建立的一個 DelayedElement 介面的實現類，它不在 java.util.concurrent 包裡。你需要自行建立你自己的 Delayed 介面的實現以使用 DelayQueue 類。
5. 鏈阻塞佇列 LinkedBlockingQueue
LinkedBlockingQueue 類實現了 BlockingQueue 介面。LinkedBlockingQueue 內部以一個鏈式結構(連結節點)對其元素進行儲存。如果需要的話，這一鏈式結構可以選擇一個上限。如果沒有定義上限，將使用 Integer.MAX_VALUE 作為上限。
LinkedBlockingQueue 內部以 FIFO(先進先出)的順序對元素進行儲存。佇列中的頭元素在所有元素之中是放入時間最久的那個，而尾元素則是最短的那個。
以下是 LinkedBlockingQueue 的初始化和使用示例程式碼：
1.BlockingQueue<String> unbounded =
new LinkedBlockingQueue<String>();
2.BlockingQueue<String> bounded =
new LinkedBlockingQueue<String>(1024);
3.
4.bounded.put("Value");
5.
6.String value = bounded.take();
6. 具有優先順序的阻塞佇列 PriorityBlockingQueue
PriorityBlockingQueue 類實現了 BlockingQueue 介面。PriorityBlockingQueue 是一個無界的併發佇列。它使用了和類 java.util.PriorityQueue 一樣的排序規則。你無法向這個佇列中插入 null 值。
所有插入到 PriorityBlockingQueue 的元素必須實現 java.lang.Comparable 介面。因此該佇列中元素的排序就取決於你自己的 Comparable 實現。
注意 PriorityBlockingQueue 對於具有相等優先順序(compare() == 0)的元素並不強制任何特定行為。
同時注意，如果你從一個 PriorityBlockingQueue 獲得一個 Iterator 的話，該 Iterator 並不能保證它對元素的遍歷是以優先順序為序的。
以下是使用 PriorityBlockingQueue 的示例：
1.BlockingQueue queue =
new PriorityBlockingQueue();
2.
3.//String implements java.lang.Comparable
4.queue.put("Value");
5.
6.String value = queue.take();
7. 同步佇列 SynchronousQueue
SynchronousQueue 類實現了 BlockingQueue 介面。SynchronousQueue 是一個特殊的佇列，它的內部同時只能夠容納單個元素。如果該佇列已有一元素的話，試圖向佇列中插入一個新元素的執行緒將會阻塞，直到另一個執行緒將該元素從佇列中抽走。同樣，如果該佇列為空，試圖向佇列中抽取一個元素的執行緒將會阻塞，直到另一個執行緒向佇列中插入了一條新的元素。
據此，把這個類稱作一個佇列顯然是誇大其詞了。它更多像是一個匯合點。
8. 阻塞雙端佇列 BlockingDeque
java.util.concurrent 包裡的 BlockingDeque 介面表示一個執行緒安放入和提取例項的雙端佇列。本小節我將給你演示如何使用 BlockingDeque。BlockingDeque 類是一個雙端佇列，在不能夠插入元素時，它將阻塞住試圖插入元素的執行緒；在不能夠抽取元素時，它將阻塞住試圖抽取的執行緒。
deque(雙端佇列) 是 "Double Ended Queue" 的縮寫。因此，雙端佇列是一個你可以從任意一端插入或者抽取元素的佇列。
BlockingDeque 的使用
線上程既是一個佇列的生產者又是這個佇列的消費者的時候可以使用到 BlockingDeque。如果生產者執行緒需要在佇列的兩端都可以插入資料，消費者執行緒需要在佇列的兩端都可以移除資料，這個時候也可以使用 BlockingDeque。BlockingDeque 圖解：
一個 BlockingDeque - 執行緒在雙端佇列的兩端都可以插入和提取元素。
一個執行緒生產元素，並把它們插入到佇列的任意一端。如果雙端佇列已滿，插入執行緒將被阻塞，直到一個移除執行緒從該佇列中移出了一個元素。如果雙端佇列為空，移除執行緒將被阻塞，直到一個插入執行緒向該佇列插入了一個新元素。
BlockingDeque 的方法
BlockingDeque 具有 4 組不同的方法用於插入、移除以及對雙端佇列中的元素進行檢查。如果請求的操作不能得到立即執行的話，每個方法的表現也不同。這些方法如下：| 拋異常 | 特定值 | 阻塞 | 超時 | |
|---|---|---|---|---|
| 插入 | addFirst(o) | offerFirst(o) | putFirst(o) | offerFirst(o, timeout, timeunit) |
| 移除 | removeFirst(o) | pollFirst(o) | takeFirst(o) | pollFirst(timeout, timeunit) |
| 檢查 | getFirst(o) | peekFirst(o) |
| 拋異常 | 特定值 | 阻塞 | 超時 | |
|---|---|---|---|---|
| 插入 | addLast(o) | offerLast(o) | putLast(o) | offerLast(o, timeout, timeunit) |
| 移除 | removeLast(o) | pollLast(o) | takeLast(o) | pollLast(timeout, timeunit) |
| 檢查 | getLast(o) | peekLast(o) |
四組不同的行為方式解釋：
拋異常：如果試圖的操作無法立即執行，拋一個異常。特定值：如果試圖的操作無法立即執行，返回一個特定的值(常常是 true / false)。阻塞：如果試圖的操作無法立即執行，該方法呼叫將會發生阻塞，直到能夠執行。超時：如果試圖的操作無法立即執行，該方法呼叫將會發生阻塞，直到能夠執行，但等待時間不會超過給定值。返回一個特定值以告知該操作是否成功(典型的是 true / false)。
BlockingDeque 繼承自 BlockingQueue
BlockingDeque 介面繼承自 BlockingQueue 介面。這就意味著你可以像使用一個 BlockingQueue 那樣使用 BlockingDeque。如果你這麼幹的話，各種插入方法將會把新元素新增到雙端佇列的尾端，而移除方法將會把雙端佇列的首端的元素移除。正如 BlockingQueue 介面的插入和移除方法一樣。以下是 BlockingDeque 對 BlockingQueue 介面的方法的具體內部實現：
| BlockingQueue | BlockingDeque |
|---|---|
| add() | addLast() |
| offer() x 2 | offerLast() x 2 |
| put() | putLast() |
| remove() | removeFirst() |
| poll() x 2 | pollFirst() |
| take() | takeFirst() |
| element() | getFirst() |
| peek() | peekFirst() |
BlockingDeque 的實現
既然 BlockingDeque 是一個介面，那麼你想要使用它的話就得使用它的眾多的實現類的其中一個。java.util.concurrent 包提供了以下 BlockingDeque 介面的實現類：LinkedBlockingDeque
BlockingDeque 程式碼示例
以下是如何使用 BlockingDeque 方法的一個簡短程式碼示例：1.BlockingDeque<String> deque =
new LinkedBlockingDeque<String>();
2.
3.deque.addFirst("1");
4.deque.addLast("2");
5.
6.String two = deque.takeLast();
7.String one = deque.takeFirst();
9. 鏈阻塞雙端佇列 LinkedBlockingDeque
LinkedBlockingDeque 類實現了 BlockingDeque 介面。deque(雙端佇列) 是 "Double Ended Queue" 的縮寫。因此，雙端佇列是一個你可以從任意一端插入或者抽取元素的佇列。(譯者注：唐僧啊，受不了。)
LinkedBlockingDeque 是一個雙端佇列，在它為空的時候，一個試圖從中抽取資料的執行緒將會阻塞，無論該執行緒是試圖從哪一端抽取資料。
以下是 LinkedBlockingDeque 例項化以及使用的示例：
1.BlockingDeque<String> deque =
new LinkedBlockingDeque<String>();
2.
3.deque.addFirst("1");
4.deque.addLast("2");
5.
6.String two = deque.takeLast();
7.String one = deque.takeFirst();
10. 併發 Map(對映) ConcurrentMap
java.util.concurrent.ConcurrentMap
java.util.concurrent.ConcurrentMap 介面表示了一個能夠對別人的訪問(插入和提取)進行併發處理的 java.util.Map。ConcurrentMap 除了從其父介面 java.util.Map 繼承來的方法之外還有一些額外的原子性方法。
ConcurrentMap 的實現
既然 ConcurrentMap 是個介面，你想要使用它的話就得使用它的實現類之一。java.util.concurrent 包具備 ConcurrentMap 介面的以下實現類：ConcurrentHashMap
ConcurrentHashMap
ConcurrentHashMap 和 java.util.HashTable 類很相似，但 ConcurrentHashMap 能夠提供比 HashTable 更好的併發效能。在你從中讀取物件的時候 ConcurrentHashMap 並不會把整個 Map 鎖住。此外，在你向其中寫入物件的時候，ConcurrentHashMap 也不會鎖住整個 Map。它的內部只是把 Map 中正在被寫入的部分進行鎖定。另外一個不同點是，在被遍歷的時候，即使是 ConcurrentHashMap 被改動，它也不會拋 ConcurrentModificationException。儘管 Iterator 的設計不是為多個執行緒的同時使用。
更多關於 ConcurrentMap 和 ConcurrentHashMap 的細節請參考官方文件。
ConcurrentMap 例子
以下是如何使用 ConcurrentMap 介面的一個例子。本示例使用了 ConcurrentHashMap 實現類：1.ConcurrentMap concurrentMap =
new ConcurrentHashMap();
2.
3.concurrentMap.put("key",
"value");
4.
5.Object value = concurrentMap.get("key");
11. 併發導航對映 ConcurrentNavigableMap
java.util.concurrent.ConcurrentNavigableMap 是一個支援併發訪問的 java.util.NavigableMap，它還能讓它的子 map 具備併發訪問的能力。所謂的 "子 map" 指的是諸如 headMap()，subMap()，tailMap() 之類的方法返回的 map。NavigableMap 中的方法不再贅述，本小節我們來看一下 ConcurrentNavigableMap 新增的方法。
headMap()
headMap(T toKey) 方法返回一個包含了小於給定 toKey 的 key 的子 map。如果你對原始 map 裡的元素做了改動，這些改動將影響到子 map 中的元素(譯者注：map 集合持有的其實只是物件的引用)。
以下示例演示了對 headMap() 方法的使用：
1.ConcurrentNavigableMap map =
new ConcurrentSkipListMap();
2.
3.map.put("1",
"one");
4.map.put("2",
"two");
5.map.put("3",
"three");
6.
7.ConcurrentNavigableMap headMap = map.headMap("2");
headMap 將指向一個只含有鍵 "1" 的 ConcurrentNavigableMap，因為只有這一個鍵小於 "2"。關於這個方法及其過載版本具體是怎麼工作的細節請參考 Java 文件。
tailMap()
tailMap(T fromKey) 方法返回一個包含了不小於給定 fromKey 的 key 的子 map。如果你對原始 map 裡的元素做了改動，這些改動將影響到子 map 中的元素(譯者注：map 集合持有的其實只是物件的引用)。
以下示例演示了對 tailMap() 方法的使用：
1.ConcurrentNavigableMap map =
new ConcurrentSkipListMap();
2.
3.map.put("1",
"one");
4.map.put("2",
"two");
5.map.put("3",
"three");
6.
7.ConcurrentNavigableMap tailMap = map.tailMap("2");
tailMap 將擁有鍵 "2" 和 "3"，因為它們不小於給定鍵 "2"。關於這個方法及其過載版本具體是怎麼工作的細節請參考 Java 文件。
subMap()
subMap() 方法返回原始 map 中，鍵介於 from(包含) 和 to (不包含) 之間的子 map。示例如下：1.ConcurrentNavigableMap map =
new ConcurrentSkipListMap();
2.
3.map.put("1",
"one");
4.map.put("2",
"two");
5.map.put("3",
"three");
6.
7.ConcurrentNavigableMap subMap = map.subMap("2",
"3");
返回的 submap 只包含鍵 "2"，因為只有它滿足不小於 "2"，比 "3" 小。
更多方法
ConcurrentNavigableMap 介面還有其他一些方法可供使用，比如：descendingKeySet()descendingMap()navigableKeySet()
關於這些方法更多資訊參考官方 Java 文件。
12. 閉鎖 CountDownLatch
java.util.concurrent.CountDownLatch 是一個併發構造，它允許一個或多個執行緒等待一系列指定操作的完成。CountDownLatch 以一個給定的數量初始化。countDown() 每被呼叫一次，這一數量就減一。通過呼叫 await() 方法之一，執行緒可以阻塞等待這一數量到達零。
以下是一個簡單示例。Decrementer 三次呼叫 countDown() 之後，等待中的 Waiter 才會從 await() 呼叫中釋放出來。
01.CountDownLatch latch =
new CountDownLatch(3);
02.
03.Waiter waiter =
new Waiter(latch);
04.Decrementer decrementer =
new Decrementer(latch);
05.
06.new
Thread(waiter) .start();
07.new
Thread(decrementer).start();
08.
09.Thread.sleep(4000);
10.
11.public
class Waiter implements
Runnable{
12.
13.CountDownLatch latch =
null;
14.
15.public
Waiter(CountDownLatch latch) {
16.this.latch = latch;
17.}
18.
19.public
void run() {
20.try
{
21.latch.await();
22.}
catch (InterruptedException e) {
23.e.printStackTrace();
24.}
25.
26.System.out.println("Waiter Released");
27.}
28.}
29.
30.public
class Decrementer implements
Runnable {
31.
32.CountDownLatch latch =
null;
33.
34.public
Decrementer(CountDownLatch latch) {
35.this.latch = latch;
36.}
37.
38.public
void run() {
39.
40.try
{
41.Thread.sleep(1000);
42.this.latch.countDown();
43.
44.Thread.sleep(1000);
45.this.latch.countDown();
46.
47.Thread.sleep(1000);
48.this.latch.countDown();
49.}
catch (InterruptedException e) {
50.e.printStackTrace();
51.}
52.}
53.}
13. 柵欄 CyclicBarrier
java.util.concurrent.CyclicBarrier 類是一種同步機制，它能夠對處理一些演算法的執行緒實現同步。換句話講，它就是一個所有執行緒必須等待的一個柵欄，直到所有執行緒都到達這裡，然後所有執行緒才可以繼續做其他事情。圖示如下：
兩個執行緒在柵欄旁等待對方。
通過呼叫 CyclicBarrier 物件的 await() 方法，兩個執行緒可以實現互相等待。一旦 N 個執行緒在等待 CyclicBarrier 達成，所有執行緒將被釋放掉去繼續執行。
建立一個 CyclicBarrier
在建立一個 CyclicBarrier 的時候你需要定義有多少執行緒在被釋放之前等待柵欄。建立 CyclicBarrier 示例：1.CyclicBarrier barrier =
new CyclicBarrier(2);
等待一個 CyclicBarrier
以下演示瞭如何讓一個執行緒等待一個 CyclicBarrier：1.barrier.await();
當然，你也可以為等待執行緒設定一個超時時間。等待超過了超時時間之後，即便還沒有達成 N 個執行緒等待 CyclicBarrier 的條件，該執行緒也會被釋放出來。以下是定義超時時間示例：
1.barrier.await(10, TimeUnit.SECONDS);
滿足以下任何條件都可以讓等待 CyclicBarrier 的執行緒釋放：
最後一個執行緒也到達 CyclicBarrier(呼叫 await())當前執行緒被其他執行緒打斷(其他執行緒呼叫了這個執行緒的 interrupt() 方法)其他等待柵欄的執行緒被打斷其他等待柵欄的執行緒因超時而被釋放外部執行緒呼叫了柵欄的 CyclicBarrier.reset() 方法
CyclicBarrier 行動
CyclicBarrier 支援一個柵欄行動，柵欄行動是一個 Runnable 例項，一旦最後等待柵欄的執行緒抵達，該例項將被執行。你可以在 CyclicBarrier 的構造方法中將 Runnable 柵欄行動傳給它：1.Runnable barrierAction = ... ;
2.CyclicBarrier barrier =
new CyclicBarrier(2, barrierAction);
CyclicBarrier 示例
以下程式碼演示瞭如何使用 CyclicBarrier：01.Runnable barrier1Action =
new Runnable() {
02.public
void run() {
03.System.out.println("BarrierAction 1 executed ");
04.}
05.};
06.Runnable barrier2Action =
new Runnable() {
07.public
void run() {
08.System.out.println("BarrierAction 2 executed ");
09.}
10.};
11.
12.CyclicBarrier barrier1 =
new CyclicBarrier(2, barrier1Action);
13.CyclicBarrier barrier2 =
new CyclicBarrier(2, barrier2Action);
14.
15.CyclicBarrierRunnable barrierRunnable1 =
16.new
CyclicBarrierRunnable(barrier1, barrier2);
17.
18.CyclicBarrierRunnable barrierRunnable2 =
19.new
CyclicBarrierRunnable(barrier1, barrier2);
20.
21.new
Thread(barrierRunnable1).start();
22.new
Thread(barrierRunnable2).start();
CyclicBarrierRunnable 類：
01.public
class CyclicBarrierRunnable
implements Runnable{
02.
03.CyclicBarrier barrier1 =
null;
04.CyclicBarrier barrier2 =
null;
05.
06.public
CyclicBarrierRunnable(
07.CyclicBarrier barrier1,
08.CyclicBarrier barrier2) {
相關推薦
Java 併發工具包 java.util.concurrent 使用者指南
譯序
1. java.util.concurrent - Java 併發工具包
Java 5 添加了一個新的包到 Java 平臺，java.util.concurrent 包。這個包包含有一系列能夠讓 Java 的併發程式設計變得更加簡單輕鬆的類。在這個包被新
Java 併發工具包-java.util.concurrent-原始碼jdk1.7全面解析
先來看看類圖：
其實從類圖我們能發現concurrent包（除去java.util.concurrent.atomic 和 java.util.concurrent.locks）中的內容並沒有特別多，大概分為四類：BlockingQueue阻塞佇列體系、Executor
Java併發工具包java.util.concurrent使用者指南
拋異常
特定值
阻塞
超時
插入
add(o)
offer(o)
put(o)
offer(o, timeout, timeunit)
移除
remove(o)
poll(o)
take(o)
poll(timeout, timeuni
Java併發程式設計-併發工具包java.util.concurrent使用指南
譯序
1. java.util.concurrent - Java併發工具包
Java 5 添加了一個新的包到 Java 平臺，java.util.concurrent 包。這個包包含有一系列能夠讓 Java 的併發程式設計變得更加簡單輕鬆的類。在這
Java多執行緒(二)Java併發工具包concurrent例項簡述
傳統的多執行緒並沒有提供高階特性，例如：訊號量、執行緒池和執行管理器等，而這些特性恰恰有助於建立強大的併發程式。新的Fork/Join框架針對當前的多核系統，也提供了並行程式設計的可能。這塊的內容是java多執行緒資訊量最大的一部分內容，本篇部落格循序漸進的，首
理解Java併發工具包執行緒池的設計
為什麼需要執行緒池？
答：主要原因是因為建立一個執行緒開銷太大，尤其是對大量的小任務需要執行這種場景。
在Java裡面建立一個執行緒，需要包含的東西：
（1）它為一個執行緒堆疊分配記憶體，該堆疊為每個執行緒方法呼叫儲存一個幀
（2）每個幀由區域性變數陣列，返回值，運算
Java併發工具包使用指南(全)
1. java.util.concurrent - Java 併發工具包
Java 5 添加了一個新的包到 Java 平臺，java.util.concurrent 包。這個包包含有一系列能夠讓 Java 的併發程式設計變得更加簡單輕鬆的類。在這個包被新增以前，
java.util.concurrent 併發工具包(二)
一、ThreadPoolExecutor 執行緒池執行者
初始化執行緒池的引數
corePoolSize
核心執行緒大小
maximumPoolSize
最大執行緒大小
keepAliveTime
空餘的多餘執行緒保持時間
unit
時間
Java例項學習 Java併發程式設計之java.util.concurrent.CopyOnWriteArrayList
CopyOnWriteArrayList
CopyOnWriteArrayList是ArrayList在併發環境下的替代品。CopyOnWriteArrayList通過增加寫時複製語義來避免併發訪問引起的問題，也就是說任何修改操作都會在底層建立一個列表的副本，也就意
Java例項學習 Java併發程式設計之java.util.concurrent.CountDownLatch
import java.util.concurrent.CountDownLatch;
/**
* 工人類
*/
class Worker {
private String name; // 名字
private long workDuration; // 工作持續時間
java 反射工具包reflections
分享圖片 class ref logs annotate .get pan can sys reflections 中包含很多的Scanner ,也就是掃描器,調用對應的方法時需要有配置對應的掃描器,不然程序會拋出異常.
掃描器結構:
使用時,我們主要使用Reflecti
Apache commons（Java常用工具包）簡介
機制 encode 解析 help IT PE tom base cit Apache Commons是一個非常有用的工具包，解決各種實際的通用問題，下面是一個簡述表，詳細信息訪問http://jakarta.apache.org/commons/index.html
Be
Java併發工具類詳解
在JDK的併發包裡提供了幾個非常有用的併發工具類。CountDownLatch、CyclicBarrier和Semaphore工具類提供了一種併發流程控制的手段，Exchanger工具類則提供了線上程間交換資料的一種手段。本章會配合一些應用場景來介紹如何使用這些工具類。
等待多執行緒完成的Cou
什麼是JDK？關於JDK（Java Development Kit）Java開發工具包的介紹
什麼是JDK？關於JDK（Java Development Kit）Java開發工具包的介紹
JDK是構建Java應用程式的關鍵平臺部分，JDK的核心是Java編譯器。
JDK是Java程式設計三個核心技術包之一，另外兩個是JVM（Java Virtual Machine）Java虛擬機器和
Java併發工具類——AtomicInteger
基本型別int的遞增等操作並不是執行緒安全的，加上synchronized又會影響效能，因此在併發情況下我們應該使用AtomicInteger，下面通過一個例子驗證一哈。
public class TestAtomicInteger {
public static void mai
淺析Java併發工具類Semaphore
淺析Java併發工具類Semaphore
1. 概述
2. 原始碼分析
3. 一個例子
4. 總結
1. 概述
Semaphore類表示訊號量。Semaphore內部主要通
Java併發程式設計包中atomic的實現原理
這是一篇來自粉絲的投稿，作者【林灣村龍貓】最近在閱讀Java原始碼，這一篇是他關於併發包中atomic類的原始碼閱讀的總結。Hollis做了一點點修改。
引子
在多執行緒的場景中，我們需要保證資料安全，就會考慮同步的方案，通常會使用synchronized或者lo
Java 併發工具類使用
java.util.concurrent 包從 JDK1.5 開始引入，目的是解決併發程式設計的執行緒安全問題，提供非常有用的併發工具類，包括 CountDownLatch、CyclicBarrier 與 Semaphore 等。
在 concurrent 包下
Java併發工具類Phaser
Phaser由java7中推出，是Java SE 7中新增的一個使用同步工具，在功能上面它與CyclicBarrier、CountDownLatch有些重疊，但是它提供了更加靈活、強大的用法。
CyclicBarrier，允許一組執行緒互相等待，直到到達某個公共屏障點。它提供的await()可以
Java常用工具包整理
BeanUtils
Commons-BeanUtils 提供對 Java 反射和自省API的包裝
Betwixt
Betwixt提供將 JavaBean 對映至 XML 文件，以及相反對映的服務