① java多線程程序設計詳細解析
一、理解多線程
多線程是這樣一種機制，它允許在程序中並發執行多個指令流，每個指令流都稱為一個線程，彼此間互相獨立。
線程又稱為輕量級進程，它和進程一樣擁有獨立的執行控制，由操作系統負責調度，區別在於線程沒有獨立的存儲空間，而是和所屬進程中的其它線程共享一個存儲空間，這使得線程間的通信遠較進程簡單。
多個線程的執行是並發的，也就是在邏輯上「同時」，而不管是否是物理上的「同時」。如果系統只有一個CPU，那麼真正的「同時」是不可能的，但是由於CPU的速度非常快，用戶感覺不到其中的區別，因此我們也不用關心它，只需要設想各個線程是同時執行即可。
多線程和傳統的單線程在程序設計上最大的區別在於，由於各個線程的控制流彼此獨立，使得各個線程之間的代碼是亂序執行的，由此帶來的線程調度，同步等問題，將在以後探討。
二、在Java中實現多線凱液慎程
我們不妨設想，為了創建一個新的線程，我們需要做些什麼？很顯然，我們必須指明這個線程所要執行的代碼，而這就是在Java中實現多線程我們所需要做的一切！
真是神奇！Java是如何做到這一點的？通過類！作為一個完全面向對象的語言，Java提供了類java.lang.Thread來方便多線程編程，這個類提供了大量的方法來方便我們控制自己的各個線程，我們以後的討論都將圍繞這個類進行。
那麼如何提供給 Java 我們要線程執行的代碼呢？讓我們來看一看 Thread 類。Thread 類最重要的方法是run()，它為Thread類的方法start()所調用，提供我們的線程所要執行的代碼。為了指定我們自己的代碼，只需要覆蓋它！
方法一：繼承 Thread 類，覆蓋方法 run()，我們在創建的 Thread 類的子類中重寫 run() ,加入線程所要執行的代碼即可。下面是一個例子：
public class MyThread extends Thread
{
int count= 1, number;
public MyThread(int num)
{
number = num;
System.out.println
("創建線程 " + number);
}
public void run() {
while(true) {
System.out.println
("線程 " + number + ":計數 " + count);
if(++count== 6) return;
}
}
public static void main(String args[])
{
for(int i = 0;
i 〈 5; i++) new MyThread(i+1).start();
}
}
這種方法簡單明了，符合大家的習慣，但是，它也有一個很大的缺點，那就是如果我們的類已經從一個類繼承（如小程序必須繼承自 Applet 類），則無法再繼承 Thread 類，這時如果我們又不想建立一個新的類，應該怎麼辦呢？
我們不妨來探索一種新的方法：我們不創建Thread類的子類，而是直接使用它，那麼我們只能將我們的方法作為參數傳遞給 Thread 類的實例，有點類似回調函數。但是 Java 沒有指針，我們只能傳遞一個包含這個方法的類的實例。
那麼如何限制這個類盯敬必須包含這一方法呢？當然是使用介面！（雖然抽象類也可滿足，但是需要繼承，而我們之所以要採用這種新方法，不就是為了避免繼承帶來的限制嗎？）
Java 提供了介面 java.lang.Runnable 來支持這種方法。
方法二：實現 Runnable 介面
Runnable介面只有一個方法run()，我們聲明自己的類實現Runnable介面並提供這一方法，將我們的線程代碼寫入其中，就完成了這一部分的任務。但是Runnable介面並沒有任何對線程的支持，我們還必須創建Thread類的實例，這一點通過Thread類的構造函數public Thread(Runnable target);來實現。下面埋禪是一個例子：
public class MyThread implements Runnable
{
int count= 1, number;
public MyThread(int num)
{
number = num;
System.out.println("創建線程 " + number);
}
public void run()
{
while(true)
{
System.out.println
("線程 " + number + ":計數 " + count);
if(++count== 6) return;
}
}
public static void main(String args[])
{
for(int i = 0; i 〈 5;
i++) new Thread(new MyThread(i+1)).start();
}
}
嚴格地說，創建Thread子類的實例也是可行的，但是必須注意的是，該子類必須沒有覆蓋 Thread 類的 run 方法，否則該線程執行的將是子類的 run 方法，而不是我們用以實現Runnable 介面的類的 run 方法，對此大家不妨試驗一下。
使用 Runnable 介面來實現多線程使得我們能夠在一個類中包容所有的代碼，有利於封裝，它的缺點在於，我們只能使用一套代碼，若想創建多個線程並使各個線程執行不同的代碼，則仍必須額外創建類，如果這樣的話，在大多數情況下也許還不如直接用多個類分別繼承 Thread 來得緊湊。
綜上所述，兩種方法各有千秋，大家可以靈活運用。
下面讓我們一起來研究一下多線程使用中的一些問題。
三、線程的四種狀態
1. 新狀態：線程已被創建但尚未執行（start() 尚未被調用）。
2. 可執行狀態：線程可以執行，雖然不一定正在執行。CPU 時間隨時可能被分配給該線程，從而使得它執行。
3. 死亡狀態：正常情況下 run() 返回使得線程死亡。調用 stop()或 destroy() 亦有同樣效果，但是不被推薦，前者會產生異常，後者是強制終止，不會釋放鎖。
4. 阻塞狀態：線程不會被分配 CPU 時間，無法執行。
四、線程的優先順序
線程的優先順序代表該線程的重要程度，當有多個線程同時處於可執行狀態並等待獲得 CPU 時間時，線程調度系統根據各個線程的優先順序來決定給誰分配 CPU 時間，優先順序高的線程有更大的機會獲得 CPU 時間，優先順序低的線程也不是沒有機會，只是機會要小一些罷了。
你可以調用 Thread 類的方法 getPriority() 和 setPriority()來存取線程的優先順序，線程的優先順序界於1(MIN_PRIORITY)和10(MAX_PRIORITY)之間，預設是5(NORM_PRIORITY)。
五、線程的同步
由於同一進程的多個線程共享同一片存儲空間，在帶來方便的同時，也帶來了訪問沖突這個嚴重的問題。Java語言提供了專門機制以解決這種沖突，有效避免了同一個數據對象被多個線程同時訪問。
由於我們可以通過 private 關鍵字來保證數據對象只能被方法訪問，所以我們只需針對方法提出一套機制，這套機制就是 synchronized 關鍵字，它包括兩種用法：synchronized 方法和 synchronized 塊。
1. synchronized 方法：通過在方法聲明中加入 synchronized關鍵字來聲明 synchronized 方法。如：
public synchronized void accessVal(int newVal);
synchronized 方法控制對類成員變數的訪問：每個類實例對應一把鎖，每個 synchronized 方法都必須獲得調用該方法的類實例的鎖方能執行，否則所屬線程阻塞，方法一旦執行，就獨占該鎖，直到從該方法返回時才將鎖釋放，此後被阻塞的線程方能獲得該鎖，重新進入可執行狀態。
這種機制確保了同一時刻對於每一個類實例，其所有聲明為 synchronized 的成員函數中至多隻有一個處於可執行狀態（因為至多隻有一個能夠獲得該類實例對應的鎖），從而有效避免了類成員變數的訪問沖突（只要所有可能訪問類成員變數的方法均被聲明為 synchronized）。
在 Java 中，不光是類實例，每一個類也對應一把鎖，這樣我們也可將類的靜態成員函數聲明為 synchronized ，以控制其對類的靜態成員變數的訪問。
synchronized 方法的缺陷：若將一個大的方法聲明為synchronized 將會大大影響效率，典型地，若將線程類的方法 run() 聲明為 synchronized ，由於在線程的整個生命期內它一直在運行，因此將導致它對本類任何 synchronized 方法的調用都永遠不會成功。當然我們可以通過將訪問類成員變數的代碼放到專門的方法中，將其聲明為 synchronized ，並在主方法中調用來解決這一問題，但是 Java 為我們提供了更好的解決辦法，那就是 synchronized 塊。
2. synchronized 塊：通過 synchronized關鍵字來聲明synchronized 塊。語法如下：
synchronized(syncObject)
{
//允許訪問控制的代碼
}
#p#副標題#e#
synchronized 塊是這樣一個代碼塊，其中的代碼必須獲得對象 syncObject （如前所述，可以是類實例或類）的鎖方能執行，具體機制同前所述。由於可以針對任意代碼塊，且可任意指定上鎖的對象，故靈活性較高。
六、線程的阻塞為了解決對共享存儲區的訪問沖突，Java 引入了同步機制，現在讓我們來考察多個線程對共享資源的訪問，顯然同步機制已經不夠了，因為在任意時刻所要求的資源不一定已經准備好了被訪問，反過來，同一時刻准備好了的資源也可能不止一個。為了解決這種情況下的訪問控制問題，Java 引入了對阻塞機制的支持。
阻塞指的是暫停一個線程的執行以等待某個條件發生（如某資源就緒），學過操作系統的同學對它一定已經很熟悉了。Java 提供了大量方法來支持阻塞，下面讓我們逐一分析。
1. sleep() 方法：sleep() 允許 指定以毫秒為單位的一段時間作為參數，它使得線程在指定的時間內進入阻塞狀態，不能得到CPU 時間，指定的時間一過，線程重新進入可執行狀態。典型地，sleep() 被用在等待某個資源就緒的情形：測試發現條件不滿足後，讓線程阻塞一段時間後重新測試，直到條件滿足為止。
2. suspend() 和 resume() 方法：兩個方法配套使用，suspend()使得線程進入阻塞狀態，並且不會自動恢復，必須其對應的resume() 被調用，才能使得線程重新進入可執行狀態。典型地，suspend() 和 resume() 被用在等待另一個線程產生的結果的情形：測試發現結果還沒有產生後，讓線程阻塞，另一個線程產生了結果後，調用 resume() 使其恢復。
3. yield() 方法：yield() 使得線程放棄當前分得的 CPU 時間，但是不使線程阻塞，即線程仍處於可執行狀態，隨時可能再次分得 CPU 時間。調用 yield() 的效果等價於調度程序認為該線程已執行了足夠的時間從而轉到另一個線程。
4. wait() 和 notify() 方法：兩個方法配套使用，wait() 使得線程進入阻塞狀態，它有兩種形式，一種允許 指定以毫秒為單位的一段時間作為參數，另一種沒有參數，前者當對應的 notify() 被調用或者超出指定時間時線程重新進入可執行狀態，後者則必須對應的 notify() 被調用。
初看起來它們與 suspend() 和 resume() 方法對沒有什麼分別，但是事實上它們是截然不同的。區別的核心在於，前面敘述的所有方法，阻塞時都不會釋放佔用的鎖（如果佔用了的話），而這一對方法則相反。
上述的核心區別導致了一系列的細節上的區別。
首先，前面敘述的所有方法都隸屬於 Thread 類，但是這一對卻直接隸屬於 Object 類，也就是說，所有對象都擁有這一對方法。初看起來這十分不可思議，但是實際上卻是很自然的，因為這一對方法阻塞時要釋放佔用的鎖，而鎖是任何對象都具有的，調用任意對象的 wait() 方法導致線程阻塞，並且該對象上的鎖被釋放。
而調用 任意對象的notify()方法則導致因調用該對象的 wait() 方法而阻塞的線程中隨機選擇的一個解除阻塞（但要等到獲得鎖後才真正可執行）。
其次，前面敘述的所有方法都可在任何位置調用，但是這一對方法卻必須在 synchronized 方法或塊中調用，理由也很簡單，只有在synchronized 方法或塊中當前線程才佔有鎖，才有鎖可以釋放。
同樣的道理，調用這一對方法的對象上的鎖必須為當前線程所擁有，這樣才有鎖可以釋放。因此，這一對方法調用必須放置在這樣的 synchronized 方法或塊中，該方法或塊的上鎖對象就是調用這一對方法的對象。若不滿足這一條件，則程序雖然仍能編譯，但在運行時會出現IllegalMonitorStateException 異常。
wait() 和 notify() 方法的上述特性決定了它們經常和synchronized 方法或塊一起使用，將它們和操作系統的進程間通信機製作一個比較就會發現它們的相似性：synchronized方法或塊提供了類似於操作系統原語的功能，它們的執行不會受到多線程機制的干擾，而這一對方法則相當於 block 和wakeup 原語（這一對方法均聲明為 synchronized）。
它們的結合使得我們可以實現操作系統上一系列精妙的進程間通信的演算法（如信號量演算法），並用於解決各種復雜的線程間通信問題。
關於 wait() 和 notify() 方法最後再說明兩點：
第一：調用 notify() 方法導致解除阻塞的線程是從因調用該對象的 wait() 方法而阻塞的線程中隨機選取的，我們無法預料哪一個線程將會被選擇，所以編程時要特別小心，避免因這種不確定性而產生問題。
第二：除了 notify()，還有一個方法 notifyAll() 也可起到類似作用，唯一的區別在於，調用 notifyAll() 方法將把因調用該對象的 wait() 方法而阻塞的所有線程一次性全部解除阻塞。當然，只有獲得鎖的那一個線程才能進入可執行狀態。
談到阻塞，就不能不談一談死鎖，略一分析就能發現，suspend() 方法和不指定超時期限的 wait() 方法的調用都可能產生死鎖。遺憾的是，Java 並不在語言級別上支持死鎖的避免，我們在編程中必須小心地避免死鎖。
以上我們對 Java 中實現線程阻塞的各種方法作了一番分析，我們重點分析了 wait() 和 notify()方法，因為它們的功能最強大，使用也最靈活，但是這也導致了它們的效率較低，較容易出錯。實際使用中我們應該靈活使用各種方法，以便更好地達到我們的目的。
七、守護線程
守護線程是一類特殊的線程，它和普通線程的區別在於它並不是應用程序的核心部分，當一個應用程序的所有非守護線程終止運行時，即使仍然有守護線程在運行，應用程序也將終止，反之，只要有一個非守護線程在運行，應用程序就不會終止。守護線程一般被用於在後台為其它線程提供服務。
可以通過調用方法 isDaemon() 來判斷一個線程是否是守護線程，也可以調用方法 setDaemon() 來將一個線程設為守護線程。
八、線程組
線程組是一個 Java 特有的概念，在 Java 中，線程組是類ThreadGroup 的對象，每個線程都隸屬於唯一一個線程組，這個線程組在線程創建時指定並在線程的整個生命期內都不能更改。
你可以通過調用包含 ThreadGroup 類型參數的 Thread 類構造函數來指定線程屬的線程組，若沒有指定，則線程預設地隸屬於名為 system 的系統線程組。
在 Java 中，除了預建的系統線程組外，所有線程組都必須顯式創建。在 Java 中，除系統線程組外的每個線程組又隸屬於另一個線程組，你可以在創建線程組時指定其所隸屬的線程組，若沒有指定，則預設地隸屬於系統線程組。這樣，所有線程組組成了一棵以系統線程組為根的樹。
Java 允許我們對一個線程組中的所有線程同時進行操作，比如我們可以通過調用線程組的相應方法來設置其中所有線程的優先順序，也可以啟動或阻塞其中的所有線程。
Java 的線程組機制的另一個重要作用是線程安全。線程組機制允許我們通過分組來區分有不同安全特性的線程，對不同組的線程進行不同的處理，還可以通過線程組的分層結構來支持不對等安全措施的採用。
Java 的 ThreadGroup 類提供了大量的方法來方便我們對線程組樹中的每一個線程組以及線程組中的每一個線程進行操作。
九、總結
在本文中，我們講述了 Java 多線程編程的方方面面，包括創建線程，以及對多個線程進行調度、管理。我們深刻認識到了多線程編程的復雜性，以及線程切換開銷帶來的多線程程序的低效性，這也促使我們認真地思考一個問題：我們是否需要多線程？何時需要多線程？
多線程的核心在於多個代碼塊並發執行，本質特點在於各代碼塊之間的代碼是亂序執行的。我們的程序是否需要多線程，就是要看這是否也是它的內在特點。
假如我們的程序根本不要求多個代碼塊並發執行，那自然不需要使用多線程；假如我們的程序雖然要求多個代碼塊並發執行，但是卻不要求亂序，則我們完全可以用一個循環來簡單高效地實現，也不需要使用多線程；只有當它完全符合多線程的特點時，多線程機制對線程間通信和線程管理的強大支持才能有用武之地，這時使用多線程才是值得的。
#p#副標題#e#
② Java 理論與實踐: 正確使用 volatile 變數 線程同步
Java語言規范中指出 為了獲得最佳速度 允許線程保存共享成員變數的私有拷貝 而且只當線程進入或者離開同步代碼塊時才與共享成員變數的原始值對比
這樣當多個線程蔽握同時與某個對象交互時 就必須要注意到要讓線程及時的得到共享成員變數的變化
而volatile關鍵字就是提示VM:對於這個成員變數不能保存它的私有拷貝 而應直接與共享成員變數交互
使用建議 在兩個或者更多的線程訪問的成員變數上使用volatile 當要訪問慎並賣的變數已在synchronized代碼塊中 或者為常量時 不必使用
由於使用volatile屏蔽掉了VM中必要的代碼優化 所以在效率上比較低 因此一定在寬逗必要時才使用此關鍵字
Java的serialization提供了一種持久化對象實例的機制 當持久化對象時 可能有一個特殊的對象數據成員 我們不想用serialization機制來保存它 為了在一個特定對象的一個域上關閉serialization 可以在這個域前加上關鍵字transient
transient是Java語言的關鍵字 用來表示一個域不是該對象串列化的一部分 當一個對象被串列化的時候 transient型變數的值不包括在串列化的表示中 然而非transient型的變數是被包括進去的
注意static變數也是可以串列化的
Java 語言中的 volatile 變數可以被看作是一種 程度較輕的 synchronized ;與 synchronized 塊相比 volatile 變數所需的編碼較少 並且運行時開銷也較少 但是它所能實現的功能也僅是 synchronized 的一部分 本文介紹了幾種有效使用 volatile 變數的模式 並強調了幾種不適合使用 volatile 變數的情形
鎖提供了兩種主要特性 互斥（mutual exclusion） 和可見性（visibility） 互斥即一次只允許一個線程持有某個特定的鎖 因此可使用該特性實現對共享數據的協調訪問協議 這樣 一次就只有一個線程能夠使用該共享數據 可見性要更加復雜一些 它必須確保釋放鎖之前對共享數據做出的更改對於隨後獲得該鎖的另一個線程是可見的 如果沒有同步機制提供的這種可見性保證 線程看到的共享變數可能是修改前的值或不一致的值 這將引發許多嚴重問題
Volatile 變數
Volatile 變數具有 synchronized 的可見性特性 但是不具備原子特性 這就是說線程能夠自動發現 volatile 變數的最新值 Volatile 變數可用於提供線程安全 但是只能應用於非常有限的一組用例 多個變數之間或者某個變數的當前值與修改後值之間沒有約束 因此 單獨使用 volatile 還不足以實現計數器 互斥鎖或任何具有與多個變數相關的不變式（Invariants）的類（例如 start <=end ）
出於簡易性或可伸縮性的考慮 您可能傾向於使用 volatile 變數而不是鎖 當使用 volatile 變數而非鎖時 某些習慣用法（idiom）更加易於編碼和閱讀 此外 volatile 變數不會像鎖那樣造成線程阻塞 因此也很少造成可伸縮性問題 在某些情況下 如果讀操作遠遠大於寫操作 volatile 變數還可以提供優於鎖的性能優勢
正確使用 volatile 變數的條件
您只能在有限的一些情形下使用 volatile 變數替代鎖 要使 volatile 變數提供理想的線程安全 必須同時滿足下面兩個條件
對變數的寫操作不依賴於當前值
該變數沒有包含在具有其他變數的不變式中
實際上 這些條件表明 可以被寫入 volatile 變數的這些有效值獨立於任何程序的狀態 包括變數的當前狀態
第一個條件的限制使 volatile 變數不能用作線程安全計數器 雖然增量操作（x++）看上去類似一個單獨操作 實際上它是一個由讀取 修改 寫入操作序列組成的組合操作 必須以原子方式執行 而 volatile 不能提供必須的原子特性 實現正確的操作需要使 x 的值在操作期間保持不變 而 volatile 變數無法實現這點 （然而 如果將值調整為只從單個線程寫入 那麼可以忽略第一個條件 ）
大多數編程情形都會與這兩個條件的其中之一沖突 使得 volatile 變數不能像 synchronized 那樣普遍適用於實現線程安全 清單 顯示了一個非線程安全的數值范圍類 它包含了一個不變式 下界總是小於或等於上界
清單 非線程安全的數值范圍類
@NotThreadSafe
public class NumberRange {
private int lower upper;
public int getLower（） { return lower; }
public int getUpper（） { return upper; }
public void setLower（int value） {
if （value > upper）
throw new IllegalArgumentException（…）
lower = value;
}
public void setUpper（int value） {
if （value < lower）
throw new IllegalArgumentException（…）
upper = value;
}
}
這種方式限制了范圍的狀態變數 因此將 lower 和 upper 欄位定義為 volatile 類型不能夠充分實現類的線程安全 從而仍然需要使用同步 否則 如果湊巧兩個線程在同一時間使用不一致的值執行 setLower 和 setUpper 的話 則會使范圍處於不一致的狀態 例如 如果初始狀態是 （ ） 同一時間內 線程 A 調用 setLower（ ） 並且線程 B 調用 setUpper（ ） 顯然這兩個操作交叉存入的值是不符合條件的 那麼兩個線程都會通過用於保護不變式的檢查 使得最後的范圍值是 （ ） 一個無效值 至於針對范圍的其他操作 我們需要使 setLower（） 和 setUpper（） 操作原子化 而將欄位定義為 volatile 類型是無法實現這一目的的
性能考慮
使用 volatile 變數的主要原因是其簡易性 在某些情形下 使用 volatile 變數要比使用相應的鎖簡單得多 使用 volatile 變數次要原因是其性能 某些情況下 volatile 變數同步機制的性能要優於鎖
很難做出准確 全面的評價 例如 X 總是比 Y 快 尤其是對 JVM 內在的操作而言 （例如 某些情況下 VM 也許能夠完全刪除鎖機制 這使得我們難以抽象地比較 volatile和 synchronized 的開銷 ）就是說 在目前大多數的處理器架構上 volatile 讀操作開銷非常低 幾乎和非 volatile 讀操作一樣 而 volatile 寫操作的開銷要比非 volatile 寫操作多很多 因為要保證可見性需要實現內存界定（Memory Fence） 即便如此 volatile 的總開銷仍然要比鎖獲取低
volatile 操作不會像鎖一樣造成阻塞 因此 在能夠安全使用 volatile 的情況下 volatile 可以提供一些優於鎖的可伸縮特性 如果讀操作的次數要遠遠超過寫操作 與鎖相比 volatile 變數通常能夠減少同步的性能開銷
正確使用 volatile 的模式
很多並發性專家事實上往往引導用戶遠離 volatile 變數 因為使用它們要比使用鎖更加容易出錯 然而 如果謹慎地遵循一些良好定義的模式 就能夠在很多場合內安全地使用 volatile 變數 要始終牢記使用 volatile 的限制 只有在狀態真正獨立於程序內其他內容時才能使用 volatile 這條規則能夠避免將這些模式擴展到不安全的用例
模式 # :狀態標志
也許實現 volatile 變數的規范使用僅僅是使用一個布爾狀態標志 用於指示發生了一個重要的一次性事件 例如完成初始化或請求停機
很多應用程序包含了一種控制結構 形式為 在還沒有準備好停止程序時再執行一些工作 如清單 所示
清單 將 volatile 變數作為狀態標志使用
volatile boolean shutdownRequested;
…
public void shutdown（） { shutdownRequested = true; }
public void doWork（） {
while （！shutdownRequested） {
// do stuff
}
}
很可能會從循環外部調用 shutdown（） 方法 即在另一個線程中 因此 需要執行某種同步來確保正確實現 shutdownRequested 變數的可見性 （可能會從 JMX 偵聽程序 GUI 事件線程中的操作偵聽程序 通過 RMI 通過一個 Web 服務等調用） 然而 使用 synchronized 塊編寫循環要比使用清單 所示的 volatile 狀態標志編寫麻煩很多 由於 volatile 簡化了編碼 並且狀態標志並不依賴於程序內任何其他狀態 因此此處非常適合使用 volatile
這種類型的狀態標記的一個公共特性是 通常只有一種狀態轉換 shutdownRequested 標志從 false 轉換為 true 然後程序停止 這種模式可以擴展到來回轉換的狀態標志 但是只有在轉換周期不被察覺的情況下才能擴展（從 false 到 true 再轉換到 false） 此外 還需要某些原子狀態轉換機制 例如原子變數
模式 # :一次性安全發布（one time safe publication）
缺乏同步會導致無法實現可見性 這使得確定何時寫入對象引用而不是原語值變得更加困難 在缺乏同步的情況下 可能會遇到某個對象引用的更新值（由另一個線程寫入）和該對象狀態的舊值同時存在 （這就是造成著名的雙重檢查鎖定（double checked locking）問題的根源 其中對象引用在沒有同步的情況下進行讀操作 產生的問題是您可能會看到一個更新的引用 但是仍然會通過該引用看到不完全構造的對象）
實現安全發布對象的一種技術就是將對象引用定義為 volatile 類型 清單 展示了一個示例 其中後台線程在啟動階段從資料庫載入一些數據 其他代碼在能夠利用這些數據時 在使用之前將檢查這些數據是否曾經發布過
清單 將 volatile 變數用於一次性安全發布
public class BackgroundFloobleLoader {
public volatile Flooble theFlooble;
public void initInBackground（） {
// do lots of stuff
theFlooble = new Flooble（） // this is the only write to theFlooble
}
}
public class SomeOtherClass {
public void doWork（） {
while （true） {
// do some stuff…
// use the Flooble but only if it is ready
if （floobleLoader theFlooble != null）
doSomething（floobleLoader theFlooble）
}
}
}
如果 theFlooble 引用不是 volatile 類型 doWork（） 中的代碼在解除對 theFlooble 的引用時 將會得到一個不完全構造的 Flooble
該模式的一個必要條件是 被發布的對象必須是線程安全的 或者是有效的不可變對象（有效不可變意味著對象的狀態在發布之後永遠不會被修改） volatile 類型的引用可以確保對象的發布形式的可見性 但是如果對象的狀態在發布後將發生更改 那麼就需要額外的同步
模式 # :獨立觀察（independent observation）
安全使用 volatile 的另一種簡單模式是 定期 發布 觀察結果供程序內部使用 例如 假設有一種環境感測器能夠感覺環境溫度 一個後台線程可能會每隔幾秒讀取一次該感測器 並更新包含當前文檔的 volatile 變數 然後 其他線程可以讀取這個變數 從而隨時能夠看到最新的溫度值
使用該模式的另一種應用程序就是收集程序的統計信息 清單 展示了身份驗證機制如何記憶最近一次登錄的用戶的名字 將反復使用 lastUser 引用來發布值 以供程序的其他部分使用
清單 將 volatile 變數用於多個獨立觀察結果的發布
public class UserManager {
public volatile String lastUser;
public boolean authenticate（String user String password） {
boolean valid = passwordIsValid（user password）
if （valid） {
User u = new User（）
activeUsers add（u）
lastUser = user;
}
return valid;
}
}
該模式是前面模式的擴展 將某個值發布以在程序內的其他地方使用 但是與一次性事件的發布不同 這是一系列獨立事件 這個模式要求被發布的值是有效不可變的 即值的狀態在發布後不會更改 使用該值的代碼需要清楚該值可能隨時發生變化
模式 # : volatile bean 模式
volatile bean 模式適用於將 JavaBeans 作為 榮譽結構 使用的框架 在 volatile bean 模式中 JavaBean 被用作一組具有 getter 和/或 setter 方法 的獨立屬性的容器 volatile bean 模式的基本原理是 很多框架為易變數據的持有者（例如 HttpSession）提供了容器 但是放入這些容器中的對象必須是線程安全的
在 volatile bean 模式中 JavaBean 的所有數據成員都是 volatile 類型的 並且 getter 和 setter 方法必須非常普通 除了獲取或設置相應的屬性外 不能包含任何邏輯 此外 對於對象引用的數據成員 引用的對象必須是有效不可變的 （這將禁止具有數組值的屬性 因為當數組引用被聲明為 volatile 時 只有引用而不是數組本身具有 volatile 語義） 對於任何 volatile 變數 不變式或約束都不能包含 JavaBean 屬性 清單 中的示例展示了遵守 volatile bean 模式的 JavaBean:
清單 遵守 volatile bean 模式的 Person 對象
@ThreadSafe
public class Person {
private volatile String firstName;
private volatile String lastName;
private volatile int age;
public String getFirstName（） { return firstName; }
public String getLastName（） { return lastName; }
public int getAge（） { return age; }
public void setFirstName（String firstName） {
this firstName = firstName;
}
public void setLastName（String lastName） {
this lastName = lastName;
}
public void setAge（int age） {
this age = age;
}
}
volatile 的高級模式
前面幾節介紹的模式涵蓋了大部分的基本用例 在這些模式中使用 volatile 非常有用並且簡單 這一節將介紹一種更加高級的模式 在該模式中 volatile 將提供性能或可伸縮性優勢
volatile 應用的的高級模式非常脆弱 因此 必須對假設的條件仔細證明 並且這些模式被嚴格地封裝了起來 因為即使非常小的更改也會損壞您的代碼！同樣 使用更高級的 volatile 用例的原因是它能夠提升性能 確保在開始應用高級模式之前 真正確定需要實現這種性能獲益 需要對這些模式進行權衡 放棄可讀性或可維護性來換取可能的性能收益 如果您不需要提升性能（或者不能夠通過一個嚴格的測試程序證明您需要它） 那麼這很可能是一次糟糕的交易 因為您很可能會得不償失 換來的東西要比放棄的東西價值更低
模式 # :開銷較低的讀 寫鎖策略
目前為止 您應該了解了 volatile 的功能還不足以實現計數器 因為 ++x 實際上是三種操作（讀 添加 存儲）的簡單組合 如果多個線程湊巧試圖同時對 volatile 計數器執行增量操作 那麼它的更新值有可能會丟失
然而 如果讀操作遠遠超過寫操作 您可以結合使用內部鎖和 volatile 變數來減少公共代碼路徑的開銷 清單 中顯示的線程安全的計數器使用 synchronized 確保增量操作是原子的 並使用 volatile 保證當前結果的可見性 如果更新不頻繁的話 該方法可實現更好的性能 因為讀路徑的開銷僅僅涉及 volatile 讀操作 這通常要優於一個無競爭的鎖獲取的開銷
清單 結合使用 volatile 和 synchronized 實現 開銷較低的讀 寫鎖
清單 結合使用 volatile 和 synchronized 實現 開銷較低的讀 寫鎖 單 結合使用 volatile 和 synchronized 實現 開銷較低的讀 寫鎖
@ThreadSafe
public class CheesyCounter {
// Employs the cheap read write lock trick
// All mutative operations MUST be done with the this lock held
@GuardedBy（ this ） private volatile int value;
public int getValue（） { return value; }
public synchronized int increment（） {
return value++;
}
}
之所以將這種技術稱之為 開銷較低的讀 寫鎖 是因為您使用了不同的同步機制進行讀寫操作 因為本例中的寫操作違反了使用 volatile 的第一個條件 因此不能使用 volatile 安全地實現計數器 您必須使用鎖 然而 您可以在讀操作中使用 volatile 確保當前值的可見性 因此可以使用鎖進行所有變化的操作 使用 volatile 進行只讀操作 其中 鎖一次只允許一個線程訪問值 volatile 允許多個線程執行讀操作 因此當使用 volatile 保證讀代碼路徑時 要比使用鎖執行全部代碼路徑獲得更高的共享度 就像讀 寫操作一樣 然而 要隨時牢記這種模式的弱點 如果超越了該模式的最基本應用 結合這兩個競爭的同步機制將變得非常困難
結束語
lishixin/Article/program/Java/hx/201311/25585
③ java並發常識
1.java並發編程是什麼
1， 保證線程安全的三種方法： a， 不要跨線程訪問共享變數b， 使共享變數是final類型的c， 將共享變數的操作加上同步 2， 一開始就將類設計成線程安全的， 比在後期重新修復它，更容易。
3， 編寫多線程程序， 首先保證它是正確的， 其次再考慮性能。 4， 無狀態或只讀對象永遠是線程安全的。
5， 不要將一個共享變數 *** 在多線程環境下（無同步或不可變性保護） 6， 多線程環境下的延遲載入需要同步的保護， 因為延遲載入會造成對象重復實例化 7， 對於volatile聲明的數值類型變數進行運算， 往往是不安全的（volatile只能保證可見性，不能保證原子性）。 詳見volatile原理與技巧中， 臟數據問題討論。
8， 當一個線程請求獲得它自己佔有的鎖時（同一把鎖的嵌套使用）， 我們稱該鎖為可重入鎖。在jdk1。
5並發包中， 提供了可重入鎖的java實現-ReentrantLock。 9， 每個共享變數，都應該由一個唯一確定的鎖保護。
創建與變數相同數目的ReentrantLock， 使他們負責每個變數的線程安全。 10，雖然縮小同步塊的范圍， 可以提升系統性能。
但在保證原子性的情況下， 不可將原子操作分解成多個synchronized塊。 11， 在沒有同步的情況下， 編譯器與處理器運行時的指令執行順序可能完全出乎意料。
原因是， 編譯器或處理器為了優化自身執行效率， 而對指令進行了的重排序（reordering）。 12， 當一個線程在沒有同步的情況下讀取變數， 它可能會得到一個過期值， 但是至少它可以看到那個線程在當時設定的一個真實數值。
而不是憑空而來的值。 這種安全保證， 稱之為最低限的安全性（out-of-thin-air safety） 在開發並發應用程序時， 有時為了大幅度提高系統的吞吐量與性能， 會採用這種無保障的做法。
但是針對， 數值的運算， 仍舊是被否決的。 13, volatile變數，只能保證可見性， 無法保證原子性。
14， 某些耗時較長的網路操作或IO， 確保執行時， 不要佔有鎖。 15， 發布（publish）對象， 指的是使它能夠被當前范圍之外的代碼所使用。
（引用傳遞）對象逸出（escape）， 指的是一個對象在尚未准備好時將它發布。 原則： 為防止逸出， 對象必須要被完全構造完後， 才可以被發布（最好的解決方式是採用同步） this關鍵字引用對象逸出 例子： 在構造函數中， 開啟線程， 並將自身對象this傳入線程， 造成引用傳遞。
而此時， 構造函數尚未執行完， 就會發生對象逸出了。 16， 必要時， 使用ThreadLocal變數確保線程封閉性（封閉線程往往是比較安全的， 但一定程度上會造成性能損耗）封閉對象的例子在實際使用過程中， 比較常見， 例如 hibernate openSessionInView機制， jdbc的connection機制。
17， 單一不可變對象往往是線程安全的（復雜不可變對象需要保證其內部成員變數也是不可變的）良好的多線程編程習慣是： 將所有的域都聲明為final， 除非它們是可變的。
2.Java線程並發協作是什麼
線程發生死鎖可能性很小，即使看似可能發生死鎖的代碼，在運行時發生死鎖的可能性也是小之又小。
發生死鎖的原因一般是兩個對象的鎖相互等待造成的。 在《Java線程：線程的同步與鎖》一文中，簡述死鎖的概念與簡單例子，但是所給的例子是不完整的，這里給出一個完整的例子。
/** * Java線程：並發協作-死鎖 * * @author Administrator 2009-11-4 22:06:13 */ public class Test { public static void main(String[] args) { DeadlockRisk dead = new DeadlockRisk(); MyThread t1 = new MyThread(dead, 1, 2); MyThread t2 = new MyThread(dead, 3, 4); MyThread t3 = new MyThread(dead, 5, 6); MyThread t4 = new MyThread(dead, 7, 8); t1。 start(); t2。
start(); t3。start(); t4。
start(); } } class MyThread extends Thread { private DeadlockRisk dead; private int a, b; MyThread(DeadlockRisk dead, int a, int b) { this。 dead = dead; this。
a = a; this。b = b; } @Override public void run() { dead。
read(); dead。write(a, b); } } class DeadlockRisk { private static class Resource { public int value; }。
3.如何學習Java高並發
1.學習 *** 並發框架的使用，如ConcurrentHashMAP,CopyOnWriteArrayList/Set等2.幾種並發鎖的使用以及線程同步與互斥，如ReentainLock,synchronized,Lock,CountDownLatch,Semaphore等3.線程池如Executors,ThreadPoolExecutor等4.Runable,Callable,RescureTask,Future,FutureTask等5.Fork-Join框架以上基本包含完了，如有缺漏請原諒。
4.並發編程的Java抽象有哪些呢
一、機器和OS級別抽象 （1）馮諾伊曼模型 經典的順序化計算模型，貌似可以保證順序化一致性，但是沒有哪個現代的多處理架構會提供順序一致性，馮氏模型只是現代多處理器行為的模糊近似。
這個計算模型，指令或者命令列表改變內存變數直接契合命令編程泛型，它以顯式的演算法為中心，這和聲明式編程泛型有區別。 就並發編程來說，會顯著的引入時間概念和狀態依賴 所以所謂的函數式編程可以解決其中的部分問題。
（2）進程和線程 進程抽象運行的程序，是操作系統資源分配的基本單位，是資源cpu，內存，IO的綜合抽象。 線程是進程式控制制流的多重分支，它存在於進程里，是操作系統調度的基本單位，線程之間同步或者非同步執行，共享進程的內存地址空間。
（3）並發與並行 並發，英文單詞是concurrent，是指邏輯上同時發生，有人做過比喻，要完成吃完三個饅頭的任務，一個人可以這個饅頭咬一口，那個饅頭咬一口，這樣交替進行，最後吃完三個饅頭，這就是並發，因為在三個饅頭上同時發生了吃的行為，如果只是吃完一個接著吃另一個，這就不是並發了，是排隊，三個饅頭如果分給三個人吃，這樣的任務完成形式叫並行，英文單詞是parallel。 回到計算機概念，並發應該是單CPU時代或者單核時代的說法，這個時候CPU要同時完成多任務，只能用時間片輪轉，在邏輯上同時發生，但在物理上是串列的。
現在大多數計算機都是多核或者多CPU，那麼現在的多任務執行方式就是物理上並行的。 為了從物理上支持並發編程，CPU提供了相應的特殊指令，比如原子化的讀改寫，比較並交換。
（4）平台內存模型 在可共享內存的多處理器體系結構中，每個處理器都有它自己的緩存，並且周期性的與主存同步，為什麼呢？因為處理器通過降低一致性來換取性能，這和CAP原理通過降低一致性來獲取伸縮性有點類似，所以大量的數據在CPU的寄存器中被計算，另外CPU和編譯器為了性能還會亂序執行，但是CPU會提供存儲關卡指令來保證存儲的同步，各種平台的內存模型或者同步指令可能不同，所以這里必須介入對內存模型的抽象，JMM就是其中之一。 二、編程模型抽象 （1）基於線程模型 （2）基於Actor模型 （3）基於STM軟體事務內存 …… Java體系是一個基於線程模型的本質編程平台，所以我們主要討論線程模型。
三、並發單元抽象 大多數並發應用程序都是圍繞執行任務進行管理的，任務是抽象，離散的工作單元，所以編寫並發程序，首要工作就是提取和分解並行任務。 一旦任務被抽象出來，他們就可以交給並發編程平台去執行，同時在任務抽象還有另一個重要抽象，那就是生命周期，一個任務的開始，結束，返回結果，都是生命周期中重要的階段。
那麼編程平台必須提供有效安全的管理任務生命周期的API。 四、線程模型 線程模型是Java的本質模型，它無所不在，所以Java開發必須搞清楚底層線程調度細節，不搞清楚當然就會有struts1,struts2的原理搞不清楚的基本災難（比如在struts2的action中塞入狀態，把struts2的action配成單例）。
用線程來抽象並發編程，是比較低級別的抽象，所以難度就大一些，難度級別會根據我們的任務特點有以下幾個類別 （1）任務非常獨立，不共享，這是最理想的情況，編程壓力為0。 (2)共享數據，壓力開始增大，必須引入鎖，Volatile變數，問題有活躍度和性能危險。
（3）狀態依賴，壓力再度增大，這時候我們基本上都是求助jdk 提供的同步工具。 五、任務執行 任務是一個抽象體，如果被抽象了出來，下一步就是交給編程平台去執行，在Java中，描述任務的一個基本介面是Runnable，可是這個抽象太有限了，它不能返回值和拋受檢查異常，所以Jdk5。
0有另外一個高級抽象Callable。 任務的執行在Jdk中也是一個底級別的Thread，線程有好處，但是大量線程就有大大的壞處，所以如果任務量很多我們並不能就創建大量的線程去服務這些任務，那麼Jdk5。
0在任務執行上做了抽象，將任務和任務執行隔離在介面背後，這樣我們就可以引入比如線程池的技術來優化執行，優化線程的創建。 任務是有生命周期的，所以Jdk5。
0提供了Future這個對象來描述對象的生命周期，通過這個future可以取到任務的結果甚至取消任務。 六、鎖 當然任務之間共享了數據，那麼要保證數據的安全，必須提供一個鎖機制來協調狀態，鎖讓數據訪問原子，但是引入了串列化，降低了並發度，鎖是降低程序伸縮性的原罪，鎖是引入上下文切換的主要原罪，鎖是引入死鎖，活鎖，優先順序倒置的絕對原罪，但是又不能沒有鎖，在Java中，鎖是一個對象，鎖提供原子和內存可見性，Volatile變數提供內存可見性不提供原子，原子變數提供可見性和原子，通過原子變數可以構建無鎖演算法和無鎖數據結構，但是這需要高高手才可以辦到。
5.Java高並發入門要怎麼學習
1、如果不使用框架，純原生Java編寫，是需要了解Java並發編程的，主要就是學習Doug Lea開發的那個java.util.concurrent包下面的API;2、如果使用框架，那麼我的理解，在代碼層面確實不會需要太多的去關注並發問題，反而是由於高並發會給系統造成很大壓力，要在緩存、資料庫操作上要多加考慮。
3、但是即使是使用框架，在工作中還是會用到多線程，就拿常見的CRUD介面來說，比如一個非常耗時的save介面，有多耗時呢？我們假設整個save執行完要10分鍾，所以，在save的時候，就需要採用非同步的方式，也就是單獨用一個線程去save，然後直接給前端返回200。
6.Java如何進行並發多連接socket編程呢
Java多個客戶端同時連接服務端，在現實生活中用得比較多。
同時執行多項任務，第一想到的當然是多線程了。下面用多線程來實現並發多連接。
import java。。
*; import java。io。
*; public class ThreadServer extends Thread { private Socket client; public ThreadServer(Socket c) { this。 client=c; } public void run() { try { BufferedReader in=new BufferedReader(new InputStreamReader(client。
getInputStream())); PrintWriter out=new PrintWriter(client。 getOutputStream()); Mutil User but can't parallel while (true) { String str=in。
readLine(); System。out。
println(str); out。 println("has receive。
"); out。
flush(); if (str。equals("end")) break; } client。
close(); } catch (IOException ex) { } finally { } } public static void main(String[] args)throws IOException { ServerSocket server=new ServerSocket(8000); while (true) { transfer location change Single User or Multi User ThreadServer mu=new ThreadServer(server。 accept()); mu。
start(); } } }J。
7.如何掌握java多線程,高並發,大數據方面的技能
線程：同一類線程共享代碼和數據空間，每個線程有獨立的運行棧和程序計數器（PC），線程切換開銷小。
（線程是cpu調度的最小單位）線程和進程一樣分為五個階段：創建、就緒、運行、阻塞、終止。多進程是指操作系統能同時運行多個任務（程序）。
多線程是指在同一程序中有多個順序流在執行。在java中要想實現多線程，有兩種手段，一種是繼續Thread類，另外一種是實現Runable介面.（其實准確來講，應該有三種，還有一種是實現Callable介面，並與Future、線程池結合使用。
8.java工程師需要掌握哪些知識
1.Core Java，就是Java基礎、JDK的類庫，很多童鞋都會說，JDK我懂，但是懂還不足夠，知其然還要知其所以然，JDK的源代碼寫的非常好，要經常查看，對使用頻繁的類，比如String， *** 類（List,Map,Set）等數據結構要知道它們的實現，不同的 *** 類有什麼區別，然後才能知道在一個具體的場合下使用哪個 *** 類更適合、更高效，這些內容直接看源代碼就OK了2.多線程並發編程，現在並發幾乎是寫服務端程序必須的技術，那對Java中的多線程就要有足夠的熟悉，包括對象鎖機制、synchronized關鍵字，concurrent包都要非常熟悉，這部分推薦你看看《Java並發編程實踐》這本書，講解的很詳細3.I/O,Socket編程，首先要熟悉Java中Socket編程，以及I/O包，再深入下去就是Java NIO，再深入下去是操作系統底層的Socket實現，了解Windows和Linux中是怎麼實現socket的4.JVM的一些知識，不需要熟悉，但是需要了解，這是Java的本質，可以說是Java的母體， 了解之後眼界會更寬闊，比如Java內存模型（會對理解Java鎖、多線程有幫助）、位元組碼、JVM的模型、各種垃圾收集器以及選擇、JVM的執行參數（優化JVM）等等，這些知識在《深入Java虛擬機》這本書中都有詳盡的解釋，或者去oracle網站上查看具體版本的JVM規范.5.一些常用的設計模式，比如單例、模板方法、代理、適配器等等，以及在Core Java和一些Java框架里的具體場景的實現，這個可能需要慢慢積累，先了解有哪些使用場景，見得多了，自己就自然而然會去用。
6.常用資料庫（Oracle、MySQL等）、SQL語句以及一般的優化7.JavaWeb開發的框架，比如Spring、iBatis等框架，同樣他們的原理才是最重要的，至少要知道他們的大致原理。8.其他一些有名的用的比較多的開源框架和包，ty網路框架，Apache mon的N多包，Google的Guava等等，也可以經常去Github上找一些代碼看看。
暫時想到的就這么多吧，1-4條是Java基礎，全部的這些知識沒有一定的時間積累是很難搞懂的，但是了解了之後會對Java有個徹底的了解，5和6是需要學習的額外技術，7-8是都是基於1-4條的，正所謂萬變不離其宗，前4條就是Java的靈魂所在，希望能對你有所幫助9.（補充）學會使用Git。如果你還在用SVN的話，趕緊投入Git的懷抱吧。
9.java 多線程的並發到底是什麼意思
一、多線程1、操作系統有兩個容易混淆的概念，進程和線程。
進程：一個計算機程序的運行實例，包含了需要執行的指令；有自己的獨立地址空間，包含程序內容和數據；不同進程的地址空間是互相隔離的；進程擁有各種資源和狀態信息，包括打開的文件、子進程和信號處理。線程：表示程序的執行流程，是CPU調度執行的基本單位；線程有自己的程序計數器、寄存器、堆棧和幀。
同一進程中的線程共用相同的地址空間，同時共享進進程鎖擁有的內存和其他資源。2、Java標准庫提供了進程和線程相關的API，進程主要包括表示進程的java.lang.Process類和創建進程的java.lang.ProcessBuilder類；表示線程的是java.lang.Thread類，在虛擬機啟動之後，通常只有Java類的main方法這個普通線程運行，運行時可以創建和啟動新的線程；還有一類守護線程（damon thread），守護線程在後台運行，提供程序運行時所需的服務。
當虛擬機中運行的所有線程都是守護線程時，虛擬機終止運行。3、線程間的可見性：一個線程對進程 *** 享的數據的修改，是否對另一個線程可見可見性問題：a、CPU採用時間片輪轉等不同演算法來對線程進行調度[java] view plainpublic class IdGenerator{ private int value = 0; public int getNext(){ return value++； } } 對於IdGenerator的getNext（)方法，在多線程下不能保證返回值是不重復的：各個線程之間相互競爭CPU時間來獲取運行機會，CPU切換可能發生在執行間隙。
以上代碼getNext（)的指令序列：CPU切換可能發生在7條指令之間，多個getNext的指令交織在一起。
④ java多線程機制中線程間可以共享相同的內存單元對還是錯
java多線程機制中線程間可以共享相同的內存單元是對的。根據查詢相關公開信息顯示，同一進程的多個線程間可以共享相同的內存單元，並可利用這些共享單元來實現數據交換、實時通信和必要的同步操作。
⑤ java多線程共同操作同一個隊列,怎麼實現
以下是兩個線程：
import java.util.*;
public class Thread_List_Operation {
//假設有這么一個隊列
static List list = new LinkedList();
public static void main(String[] args) {
Thread t;
t = new Thread(new T1());
t.start();
t = new Thread(new T2());
t.start();
}
}
//線程T1,用來給list添加新元素
class T1 implements Runnable{
void getElemt(Object o){
Thread_List_Operation.list.add(o);
System.out.println(Thread.currentThread().getName() + "為隊列添加了一個元素");
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
getElemt(new Integer(1));
}
}
}
//線程T2,用來給list添加新元素
class T2 implements Runnable{
void getElemt(Object o){
Thread_List_Operation.list.add(o);
System.out.println(Thread.currentThread().getName() + "為隊列添加了一個元素");
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
getElemt(new Integer(1));
}
}
}
//結果（亂序）
Thread-0為隊列添加了一個元素
Thread-1為隊列添加了一個元素
Thread-0為隊列添加了一個元素
Thread-1為隊列添加了一個元素
Thread-1為隊列添加了一個元素
Thread-1為隊列添加了一個元素
Thread-1為隊列添加了一個元素
Thread-1為隊列添加了一個元素
Thread-1為隊列添加了一個元素
Thread-1為隊列添加了一個元素
Thread-1為隊列添加了一個元素
Thread-1為隊列添加了一個元素
Thread-0為隊列添加了一個元素
Thread-0為隊列添加了一個元素
Thread-0為隊列添加了一個元素
Thread-0為隊列添加了一個元素
Thread-0為隊列添加了一個元素
Thread-0為隊列添加了一個元素
Thread-0為隊列添加了一個元素
Thread-0為隊列添加了一個元素