Java線程新特徵——Java併發庫

時間 2019-11-08

標籤 java 線程特徵併發欄目 Java 简体版

原文原文鏈接

1、線程池

Sun在Java5中，對Java線程的類庫作了大量的擴展，其中線程池就是Java5的新特徵之一，除了線程池以外，還有不少多線程相關的內容，爲多線程的編程帶來了極大便利。爲了編寫高效穩定可靠的多線程程序，線程部分的新增內容顯得尤其重要。

有關Java5線程新特徵的內容所有在java.util.concurrent下面，裏面包含數目衆多的接口和類，熟悉這部分API特徵是一項艱難的學習過程。固然新特徵對作多線程程序沒有必須的關係，在java5以前通用能夠寫出很優秀的多線程程序。只是代價不同而已。

線程池的基本思想仍是一種對象池的思想，開闢一塊內存空間，裏面存放了衆多（未死亡）的線程，池中線程執行調度由池管理器來處理。當有線程任務時，從池中取一個，執行完成後線程對象歸池，這樣能夠避免反覆建立線程對象所帶來的性能開銷，節省了系統的資源。

在Java5以前，要實現一個線程池是至關有難度的，如今Java5爲咱們作好了一切，咱們只須要按照提供的API來使用，便可享受線程池帶來的極大便利。

Java5的線程池分好多種：固定尺寸的線程池、可變尺寸鏈接池。

在使用線程池以前，必須知道如何去建立一個線程池，在Java5中，須要瞭解的是java.util.concurrent.Executors類的API，這個類提供大量建立鏈接池的靜態方法，是必須掌握的。

a、固定大小的線程池

import java.util.concurrent.Executors; import java.util.concurrent.ExecutorService; /** * Java線程：線程池- * * */ public class Test { public static void main(String[] args) { //建立一個可重用固定線程數的線程池 ExecutorService pool = Executors.newFixedThreadPool(2); //建立實現了Runnable接口對象，Thread對象固然也實現了Runnable接口 Thread t1 = new MyThread(); Thread t2 = new MyThread(); Thread t3 = new MyThread(); Thread t4 = new MyThread(); Thread t5 = new MyThread(); //將線程放入池中進行執行  pool.execute(t1); pool.execute(t2); pool.execute(t3); pool.execute(t4); pool.execute(t5); //關閉線程池  pool.shutdown(); } } class MyThread extends Thread{ @Override public void run() { System.out.println(Thread.currentThread().getName()+"正在執行..."); } }

運行結果：html

pool-1-thread-1正在執行... pool-1-thread-1正在執行... pool-1-thread-2正在執行... pool-1-thread-1正在執行... pool-1-thread-2正在執行...

若是將線程池的大小改成4，則運行結果以下：java

pool-1-thread-2正在執行... pool-1-thread-3正在執行... pool-1-thread-3正在執行... pool-1-thread-2正在執行... pool-1-thread-1正在執行...

b、單任務線程池

在上例的基礎上改一行建立pool對象的代碼爲：編程

 //建立一個使用單個 worker 線程的 Executor，以無界隊列方式來運行該線程。 ExecutorService pool = Executors.newSingleThreadExecutor();

則，運行結果爲：api

pool-1-thread-1正在執行... pool-1-thread-1正在執行... pool-1-thread-1正在執行... pool-1-thread-1正在執行... pool-1-thread-1正在執行...

對於以上兩種鏈接池，大小都是固定的，當要加入的池的線程（或者任務）超過池最大尺寸時候，則入此線程池須要排隊等待。

一旦池中有線程完畢，則排隊等待的某個線程會入池執行。

c、可變尺寸的線程池

與上面的相似，只是改動下pool的建立方式：安全

  //建立一個可根據須要建立新線程的線程池，可是在之前構造的線程可用時將重用它們。 ExecutorService pool = Executors.newCachedThreadPool();

運行結果以下：多線程

pool-1-thread-1正在執行...
pool-1-thread-5正在執行... pool-1-thread-4正在執行... pool-1-thread-3正在執行... pool-1-thread-2正在執行...

d、延遲鏈接池

package concurrent; import java.util.concurrent.Executors; import java.util.concurrent.ExecutorService; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ScheduledThreadPoolExecutor; import java.util.concurrent.TimeUnit; /** * Java線程：線程池- * * */ public class Test { public static void main(String[] args) { //建立一個線程池，它可那排在給定延遲後運行命令或者按期地執行 ScheduledExecutorService pool = Executors.newScheduledThreadPool(2); //建立實現了Runnable接口對象，Thread對象固然也實現了Runnable接口 Thread t1 = new MyThread(); Thread t2 = new MyThread(); Thread t3 = new MyThread(); Thread t4 = new MyThread(); Thread t5 = new MyThread(); //將線程放入池中進行執行  pool.execute(t1); pool.execute(t2); pool.execute(t3); //使用延遲執行風格的方法 pool.schedule(t4, 5, TimeUnit.SECONDS); pool.schedule(t5, 10, TimeUnit.SECONDS); //關閉線程池  pool.shutdown(); } } class MyThread extends Thread{ @Override public void run() { System.out.println(Thread.currentThread().getName()+"正在執行..."); } }

e、單任務鏈接線程池

在d的代碼基礎上，作改動併發

 //建立一個單線程執行程序，它可安排在給定延遲後運行命令或者按期地執行。 ScheduledExecutorService pool = Executors.newSingleThreadScheduledExecutor();

運行時，會發現，t4延遲5s後獲得執行，t5延遲10s後獲得執行。運行結果以下：ide

pool-1-thread-2正在執行...
pool-1-thread-1正在執行... pool-1-thread-1正在執行... pool-1-thread-2正在執行... pool-1-thread-1正在執行...

f、自定義線程池

package concurrent; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; /** * Java線程：線程池-自定義線程池 * * */ public class Test { public static void main(String[] args) { //建立等待隊列 BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>(20); //建立一個單線程執行程序，它可安排在給定延遲後運行命令或者按期地執行。 ThreadPoolExecutor pool = new ThreadPoolExecutor(2,3,2,TimeUnit.MILLISECONDS,bqueue); //建立實現了Runnable接口對象，Thread對象固然也實現了Runnable接口 Thread t1 = new MyThread(); Thread t2 = new MyThread(); Thread t3 = new MyThread(); Thread t4 = new MyThread(); Thread t5 = new MyThread(); Thread t6 = new MyThread(); Thread t7 = new MyThread(); //將線程放入池中進行執行  pool.execute(t1); pool.execute(t2); pool.execute(t3); pool.execute(t4); pool.execute(t5); pool.execute(t6); pool.execute(t7); //關閉線程池  pool.shutdown(); } } class MyThread extends Thread { @Override public void run() { System.out.println(Thread.currentThread().getName() + "正在執行..."); try { Thread.sleep(100L); } catch (InterruptedException e) { e.printStackTrace(); } } }

運行結構以下：
建立自定義線程池的構造方法不少，本例中參數的含義以下：工具

ThreadPoolExecutor

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue)

用給定的初始參數和默認的線程工廠及處理程序建立新的 ThreadPoolExecutor。使用 Executors 工廠方法之一比使用此通用構造方法方便得多。

參數：: corePoolSize - 池中所保存的線程數，包括空閒線程。; maximumPoolSize - 池中容許的最大線程數。; keepAliveTime - 當線程數大於核心時，此爲終止前多餘的空閒線程等待新任務的最長時間。; unit - keepAliveTime 參數的時間單位。; workQueue - 執行前用於保持任務的隊列。此隊列僅保持由 execute 方法提交的 Runnable 任務。
拋出：: IllegalArgumentException - 若是 corePoolSize 或 keepAliveTime 小於零，或者 maximumPoolSize 小於或等於零，或者 corePoolSize 大於 maximumPoolSize。; NullPointerException - 若是 workQueue 爲 null

自定義鏈接池稍微麻煩些，不過經過建立的ThreadPoolExecutor線程池對象，能夠獲取到當前線程池的尺寸、正在執行任務的線程數、工做隊列等等。

2、有返回值的線程

在Java5以前，線程是沒有返回值的，經常爲了「有」返回值，破費周折，並且代碼很很差寫。或者乾脆繞過這道坎，走別的路了。如今Java終於有可返回值的線程了。

可返回值的任務必須實現Callable接口，相似的，無返回值的任務必須實現Runnable接口。

執行Callable任務後，能夠獲取一個Future的對象，在該對象上調用get就能夠獲取到Callable任務返回的Object了。

下面是一個簡單的例子：性能

package MultiThread; import java.util.concurrent.*; /** * Java線程：有返回值的線程 * * */ public class Test { public static void main(String[] args) throws ExecutionException, InterruptedException { //建立一個線程池 ExecutorService pool = Executors.newFixedThreadPool(2); //建立兩個有返回值的任務 Callable<String> c1 = new MyCallable("A"); Callable<String> c2 = new MyCallable("B"); //執行任務並獲取Future對象 Future<String> f1 = pool.submit(c1); Future<String> f2 = pool.submit(c2); //從Future對象上獲取任務的返回值，並輸出到控制檯 System.out.println(">>>"+f1.get().toString()); System.out.println(">>>"+f2.get().toString()); //關閉線程池  pool.shutdown(); } } class MyCallable implements Callable<String>{ private String oid; MyCallable(String oid) { this.oid = oid; } @Override public String call() throws Exception { return oid+"任務返回的內容"; } }

運行結果：

>>>A任務返回的內容
>>>B任務返回的內容

比較簡單，要深刻了解還須要看Callable和Future接口的API啊。

3、併發庫的鎖

在Java5中，專門提供了鎖對象，利用鎖能夠方便的實現資源的封鎖，用來控制對競爭資源併發訪問的控制，這些內容主要集中在java.util.concurrent.locks 包下面，裏面有三個重要的接口Condition、Lock、ReadWriteLock。

接口摘要
Condition	`Condition` 將 `Object` 監視器方法（`wait`、`notify` 和 `notifyAll`）分解成大相徑庭的對象，以便經過將這些對象與任意 `Lock` 實現組合使用，爲每一個對象提供多個等待 set（wait-set）。
Lock	`Lock` 實現提供了比使用 `synchronized` 方法和語句可得到的更普遍的鎖定操做。
ReadWriteLock	`ReadWriteLock` 維護了一對相關的`鎖`，一個用於只讀操做，另外一個用於寫入操做。

有關鎖的介紹,API文檔解說不少，看得很煩，仍是看個例子再看文檔比較容易理解

a、普通鎖

package MultiThread; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * Java線程：鎖 * * */ public class Test { public static void main(String[] args) { //建立併發訪問的帳戶 MyCount myCount = new MyCount("95599200901215522", 10000); //建立一個鎖對象 Lock lock = new ReentrantLock(); //建立一個線程池 ExecutorService pool = Executors.newCachedThreadPool(); //建立一些併發訪問用戶，一個信用卡，存的存，取的取，好熱鬧啊 UserThread ut1 = new UserThread("取款線程1", myCount, -4000, lock); UserThread ut2 = new UserThread("存款線程1", myCount, 6000, lock); UserThread ut3 = new UserThread("取款線程2", myCount, -8000, lock); UserThread ut4 = new UserThread("存款線程2", myCount, 800, lock); //在線程池中執行各個用戶的操做  pool.execute(ut1); pool.execute(ut2); pool.execute(ut3); pool.execute(ut4); //關閉線程池  pool.shutdown(); } } /** * 信用卡的用戶 線程 * 多個用戶線程操做該信用卡 */ class UserThread implements Runnable { private String threadName; //用戶線程 private MyCount myCount; //所要操做的帳戶 private int iocash; //操做的金額，固然有正負之分了 private Lock myLock; //執行操做所需的鎖對象  UserThread(String name, MyCount myCount, int iocash, Lock myLock) { this.threadName = name; this.myCount = myCount; this.iocash = iocash; this.myLock = myLock; } public void run() { //獲取鎖  myLock.lock(); //執行現金業務 System.out.println(threadName + "正在操做" + myCount + "帳戶，操做金額爲" + iocash + "，當前金額爲" + myCount.getCash()); myCount.setCash(myCount.getCash() + iocash); System.out.println("\t操做成功，操做金額爲" + iocash + "，當前金額爲" + myCount.getCash()); //釋放鎖，不然別的線程沒有機會執行了  myLock.unlock(); } } /** * 信用卡帳戶，可隨意透支 */ class MyCount { private String oid; //帳號 private int cash; //帳戶餘額  MyCount(String oid, int cash) { this.oid = oid; this.cash = cash; } public String getOid() { return oid; } public void setOid(String oid) { this.oid = oid; } public int getCash() { return cash; } public void setCash(int cash) { this.cash = cash; } @Override public String toString() { return "MyCount{" + "oid='" + oid + '\'' + ", cash=" + cash + '}'; } }

運行結果：

取款線程1正在操做MyCount{oid='95599200901215522', cash=10000}帳戶，操做金額爲-4000，當前金額爲10000 操做成功，操做金額爲-4000，當前金額爲6000 存款線程1正在操做MyCount{oid='95599200901215522', cash=6000}帳戶，操做金額爲6000，當前金額爲6000 操做成功，操做金額爲6000，當前金額爲12000 存款線程2正在操做MyCount{oid='95599200901215522', cash=12000}帳戶，操做金額爲800，當前金額爲12000 操做成功，操做金額爲800，當前金額爲12800 取款線程2正在操做MyCount{oid='95599200901215522', cash=12800}帳戶，操做金額爲-8000，當前金額爲12800 操做成功，操做金額爲-8000，當前金額爲4800

從上面的輸出能夠看到，利用鎖對象太方便了，比直接在某個不知情的對象上用鎖清晰多了。但必定要注意的是，在獲取了鎖對象後，用完後應該儘快釋放鎖，以便別的等待該鎖的線程有機會去執行。

b、讀寫鎖

在a中提到了Lock接口以及對象，使用它能夠很優雅的控制了競爭資源的安全訪問，可是這種鎖不區分讀寫，稱這種鎖爲普通鎖。爲了提升性能，Java提供了讀寫鎖，在讀的地方使用讀鎖，在寫的地方使用寫鎖，靈活控制，在必定程度上提升了程序的執行效率。

Java中讀寫鎖有個接口java.util.concurrent.locks.ReadWriteLock，也有具體的實現ReentrantReadWriteLock，詳細的API能夠查看JavaAPI文檔。

下面這個例子是在文例子的基礎上，將普通鎖改成讀寫鎖，並添加帳戶餘額查詢的功能，代碼以下：

package MultiThread; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantLock; import java.util.concurrent.locks.ReentrantReadWriteLock; /** * Java線程：鎖 * * */ public class Test { public static void main(String[] args) { //建立併發訪問的帳戶 MyCount myCount = new MyCount("95599200901215522", 10000); //建立一個鎖對象 ReadWriteLock lock = new ReentrantReadWriteLock(); //建立一個線程池 ExecutorService pool = Executors.newCachedThreadPool(); //建立一些併發訪問用戶線程，一個信用卡，存的存，取的取，好熱鬧啊 UserThread ut1 = new UserThread("取款線程1", myCount, -4000, lock,false); UserThread ut2 = new UserThread("存款線程1", myCount, 6000, lock,false); UserThread ut3 = new UserThread("取款線程2", myCount, -8000, lock,false); UserThread ut4 = new UserThread("存款線程2", myCount, 800, lock,false); UserThread ut5 = new UserThread("查詢", myCount, 0, lock,true); //在線程池中執行各個用戶的操做  pool.execute(ut1); pool.execute(ut2); pool.execute(ut3); pool.execute(ut4); pool.execute(ut5); //關閉線程池  pool.shutdown(); } } /** * 信用卡的用戶 線程 * 多個用戶線程操做該信用卡 */ class UserThread implements Runnable { private String threadName; //用戶線程 private MyCount myCount; //所要操做的帳戶 private int iocash; //操做的金額，固然有正負之分了 private ReadWriteLock myLock; //執行操做所需的鎖對象 private boolean ischeck; //是否查詢  UserThread(String name, MyCount myCount, int iocash, ReadWriteLock myLock,boolean ischeck) { this.threadName = name; this.myCount = myCount; this.iocash = iocash; this.myLock = myLock; this.ischeck=ischeck; } public void run() { if(ischeck){ //獲取讀鎖  myLock.readLock().lock(); //執行查詢 System.out.println("讀："+threadName + "正在查詢" + myCount + "帳戶，，當前金額爲" + myCount.getCash()); //釋放獲取到的讀鎖  myLock.readLock().unlock(); }else{ //獲取寫鎖  myLock.writeLock().lock(); myCount.setCash(myCount.getCash() + iocash); System.out.println("寫："+threadName+"操做成功，操做金額爲" + iocash + "，當前金額爲" + myCount.getCash()); //釋放鎖獲取到的寫鎖  myLock.writeLock().unlock(); } } } /** * 信用卡帳戶，可隨意透支 */ class MyCount { private String oid; //帳號 private int cash; //帳戶餘額  MyCount(String oid, int cash) { this.oid = oid; this.cash = cash; } public String getOid() { return oid; } public void setOid(String oid) { this.oid = oid; } public int getCash() { return cash; } public void setCash(int cash) { this.cash = cash; } @Override public String toString() { return "MyCount{" + "oid='" + oid + '\'' + ", cash=" + cash + '}'; } }

運行結果：

寫：取款線程1操做成功，操做金額爲-4000，當前金額爲6000 寫：取款線程2操做成功，操做金額爲-8000，當前金額爲-2000 寫：存款線程1操做成功，操做金額爲6000，當前金額爲4000 讀：查詢正在查詢MyCount{oid='95599200901215522', cash=4000}帳戶，，當前金額爲4000 寫：存款線程2操做成功，操做金額爲800，當前金額爲4800

在實際開發中，最好在能用讀寫鎖的狀況下使用讀寫鎖，而不要用普通鎖，以求更好的性能。

4、信號量

Java的信號量其實是一個功能完畢的計數器，對控制必定資源的消費與回收有着很重要的意義，信號量經常用於多線程的代碼中，並能監控有多少數目的線程等待獲取資源，而且經過信號量能夠得知可用資源的數目等等，這裏老是在強調「數目」二字，但不能指出來有哪些在等待，哪些資源可用。

所以，本人認爲，這個信號量類若是能返回數目，還能知道哪些對象在等待，哪些資源可以使用，就很是完美了，僅僅拿到這些歸納性的數字，對精確控制意義不是很大。目前還沒想到更好的用法。

下面是一個簡單的例子：

package MultiThread; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Semaphore; /** * Java線程：信號量 * * */ public class Test { public static void main(String[] args) { MyPool myPool = new MyPool(20); //建立線程池 ExecutorService threadPool = Executors.newFixedThreadPool(2); MyThread t1 = new MyThread("任務A", myPool, 3); MyThread t2 = new MyThread("任務B", myPool, 12); MyThread t3 = new MyThread("任務C", myPool, 7); //在線程池中執行任務  threadPool.execute(t1); threadPool.execute(t2); threadPool.execute(t3); //關閉池  threadPool.shutdown(); } } /** * 一個池 */ class MyPool { private Semaphore sp; //池相關的信號量 /** * 池的大小，這個大小會傳遞給信號量 * * @param size 池的大小 */ MyPool(int size) { this.sp = new Semaphore(size); } public Semaphore getSp() { return sp; } public void setSp(Semaphore sp) { this.sp = sp; } } class MyThread extends Thread { private String threadName; //線程的名稱 private MyPool pool; //自定義池 private int x; //申請信號量的大小  MyThread(String threadName, MyPool pool, int x) { this.threadName = threadName; this.pool = pool; this.x = x; } public void run() { try { //今後信號量獲取給定數目的許可  pool.getSp().acquire(x); //todo：也許這裏能夠作更復雜的業務 System.out.println(threadName + "成功獲取了" + x + "個許可！"); } catch (InterruptedException e) { e.printStackTrace(); } finally { //釋放給定數目的許可，將其返回到信號量。  pool.getSp().release(x); System.out.println(threadName + "釋放了" + x + "個許可！"); } } }

運行結果：

任務A成功獲取了3個許可！
任務B成功獲取了12個許可！
任務B釋放了12個許可！
任務C成功獲取了7個許可！
任務A釋放了3個許可！
任務C釋放了7個許可！

從結果能夠看出，信號量僅僅是對池資源進行監控，但不保證線程的安全，所以，在使用時候，應該本身控制線程的安全訪問池資源。

5、阻塞隊列

阻塞隊列是Java5線程新特徵中的內容，Java定義了阻塞隊列的接口java.util.concurrent.BlockingQueue，阻塞隊列的概念是，一個指定長度的隊列，若是隊列滿了，添加新元素的操做會被阻塞等待，直到有空位爲止。一樣，當隊列爲空時候，請求隊列元素的操做一樣會阻塞等待，直到有可用元素爲止。

有了這樣的功能，就爲多線程的排隊等候的模型實現開闢了便捷通道，很是有用。

java.util.concurrent.BlockingQueue繼承了java.util.Queue接口，能夠參看API文檔。

下面給出一個簡單應用的例子：

package MultiThread; import java.util.concurrent.BlockingQueue; import java.util.concurrent.ArrayBlockingQueue; /** * Java線程：併發庫-阻塞隊列 * * */ public class Test { public static void main(String[] args) throws InterruptedException { BlockingQueue<Integer> bqueue = new ArrayBlockingQueue<Integer>(20); for (int i = 0; i < 30; i++) { //將指定元素添加到此隊列中，若是沒有可用空間，將一直等待（若是有必要）。  bqueue.put(i); System.out.println("向阻塞隊列中添加了元素:" + i); } System.out.println("程序到此運行結束，即將退出----"); } }

運行結果：

因爲阻塞隊列的大小爲20個，當超過這個數目，又沒有元素出隊列的時候，隊列將會阻塞。到後來的某一個時刻，程序將阻塞隊列中的元素出隊列，後面的元素才能夠進隊列。

6、阻塞棧

對於阻塞棧，與阻塞隊列類似。不一樣點在於棧是「後入先出」的結構，每次操做的是棧頂，而隊列是「先進先出」的結構，每次操做的是隊列頭。

這裏要特別說明一點的是，阻塞棧是Java6的新特徵。、

Java爲阻塞棧定義了接口：java.util.concurrent.BlockingDeque，其實現類也比較多，具體能夠查看JavaAPI文檔。

下面看一個簡單例子：

package MultiThread; import java.util.concurrent.BlockingDeque; import java.util.concurrent.LinkedBlockingDeque; class HelloWorldThread { /** * Java線程：併發庫-阻塞棧 * * */ public static void main(String[] args) { BlockingDeque<Integer> bstack=new LinkedBlockingDeque<Integer>(20) ; for(int i=0;i<30;i++){ //將指定元素添加到阻塞棧中，若是沒有可用空間，將一直等待（若是有必要）。  bstack.push(i); System.out.println("向阻塞棧中添加了元素:" + i); if(bstack.size()==20){ System.out.println("隊列滿，彈出"+bstack.pop()); System.out.println("隊列滿，彈出"+bstack.pop()); System.out.println("隊列滿，彈出"+bstack.pop()); } } System.out.println("程序到此運行結束，即將退出----"); } }

程序的運行結果和阻塞隊列的運行結果同樣，程序並沒結束，二是阻塞住了，緣由是棧已經滿了，後面追加元素的操做都被阻塞了。

7、條件變量

條件變量是Java5線程中很重要的一個概念，顧名思義，條件變量就是表示條件的一種變量。可是必須說明，這裏的條件是沒有實際含義的，僅僅是個標記而已，而且條件的含義每每經過代碼來賦予其含義。這裏的條件和普通意義上的條件表達式有着天壤之別。條件變量都實現了java.util.concurrent.locks.Condition接口，條件變量的實例化是經過一個Lock對象上調用newCondition()方法來獲取的，這樣，條件就和一個鎖對象綁定起來了。所以，Java中的條件變量只能和鎖配合使用，來控制併發程序訪問競爭資源的安全。

條件變量的出現是爲了更精細控制線程等待與喚醒，在Java5以前，線程的等待與喚醒依靠的是Object對象的wait()和notify()/notifyAll()方法，這樣的處理不夠精細。而在Java5中，一個鎖能夠有多個條件，每一個條件上能夠有多個線程等待，經過調用await()方法，可讓線程在該條件下等待。當調用signalAll()方法，又能夠喚醒該條件下的等待的線程。有關Condition接口的API能夠具體參考JavaAPI文檔。

條件變量比較抽象，緣由是他不是天然語言中的條件概念，而是程序控制的一種手段。

下面以一個銀行存取款的模擬程序爲例來揭蓋Java多線程條件變量的神祕面紗：

有一個帳戶，多個用戶（線程）在同時操做這個帳戶，有的存款有的取款，存款隨便存，取款有限制，不能透支，任何試圖透支的操做都將等待裏面有足夠存款才執行操做。

package MultiThread; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * Java線程：條件變量 * * @author leizhimin 2009-11-5 10:57:29 */ public class Test { public static void main(String[] args) { //建立併發訪問的帳戶 MyCount myCount = new MyCount("95599200901215522", 10000); //建立一個線程池 ExecutorService pool = Executors.newFixedThreadPool(2); Thread t1 = new SaveThread("張三", myCount, 2000); Thread t2 = new SaveThread("李四", myCount, 3600); Thread t3 = new DrawThread("王五", myCount, 2700); Thread t4 = new SaveThread("老張", myCount, 600); Thread t5 = new DrawThread("老牛", myCount, 1300); Thread t6 = new DrawThread("胖子", myCount, 800); //執行各個線程  pool.execute(t1); pool.execute(t2); pool.execute(t3); pool.execute(t4); pool.execute(t5); pool.execute(t6); //關閉線程池  pool.shutdown(); } } /** * 存款線程類 */ class SaveThread extends Thread { private String name; //操做人 private MyCount myCount; //帳戶 private int x; //存款金額  SaveThread(String name, MyCount myCount, int x) { this.name = name; this.myCount = myCount; this.x = x; } public void run() { myCount.saving(x, name); } } /** * 取款線程類 */ class DrawThread extends Thread { private String name; //操做人 private MyCount myCount; //帳戶 private int x; //存款金額  DrawThread(String name, MyCount myCount, int x) { this.name = name; this.myCount = myCount; this.x = x; } public void run() { myCount.drawing(x, name); } } /** * 普通銀行帳戶，不可透支 */ class MyCount { private String oid; //帳號 private int cash; //帳戶餘額 private Lock lock = new ReentrantLock(); //帳戶鎖 private Condition _save = lock.newCondition(); //存款條件 private Condition _draw = lock.newCondition(); //取款條件  MyCount(String oid, int cash) { this.oid = oid; this.cash = cash; } /** * 存款 * * @param x 操做金額 * @param name 操做人 */ public void saving(int x, String name) { lock.lock(); //獲取鎖 if (x > 0) { cash += x; //存款 System.out.println(name + "存款" + x + "，當前餘額爲" + cash); } _draw.signalAll(); //喚醒全部取款等待線程 lock.unlock(); //釋放鎖  } /** * 取款 * * @param x 操做金額 * @param name 操做人 */ public void drawing(int x, String name) { lock.lock(); //獲取鎖 try { if (cash - x < 0) { _draw.await(); //阻塞取款操做 } else { cash -= x; //取款 System.out.println(name + "取款" + x + "，當前餘額爲" + cash); } _save.signalAll(); //喚醒全部存款操做線程 } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); //釋放鎖  } } }

固然，除了使用併發庫來實現存取款操做，咱們也可使用synchronized的方法、synchronized的代碼塊來實現。對比並發庫、synchronized方法、synchronized代碼塊，第一種最靈活，第二種代碼最簡單，第三種容易犯錯。

8、原子量

所謂的原子量即操做變量的操做是「原子的」，該操做不可再分，所以是線程安全的。爲什麼要使用原子變量呢，緣由是多個線程對單個變量操做也會引發一些問題。在Java5以前，能夠經過volatile、synchronized關鍵字來解決併發訪問的安全問題，但這樣太麻煩。Java5以後，專門提供了用來進行單變量多線程併發安全訪問的工具包java.util.concurrent.atomic，其中的類也很簡單。

下面給出一個反面例子（切勿模仿）：

package MultiThread; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.atomic.AtomicLong; /** * Java線程：新特徵-原子量 * * */ public class Test { public static void main(String[] args) { ExecutorService pool = Executors.newFixedThreadPool(2); Runnable t1 = new MyRunnable("張三", 2000); Runnable t2 = new MyRunnable("李四", 3600); Runnable t3 = new MyRunnable("王五", 2700); Runnable t4 = new MyRunnable("老張", 600); Runnable t5 = new MyRunnable("老牛", 1300); Runnable t6 = new MyRunnable("胖子", 800); //執行各個線程  pool.execute(t1); pool.execute(t2); pool.execute(t3); pool.execute(t4); pool.execute(t5); pool.execute(t6); //關閉線程池  pool.shutdown(); } } class MyRunnable implements Runnable { private static AtomicLong aLong = new AtomicLong(10000); //原子量，每一個線程均可以自由操做 private String name; //操做人 private int x; //操做數額  MyRunnable(String name, int x) { this.name = name; this.x = x; } public void run() { System.out.println(name + "執行了" + x + "，當前餘額：" + aLong.addAndGet(x)); } }

運行結果一：

李四執行了3600，當前餘額：13600 張三執行了2000，當前餘額：15600 老張執行了600，當前餘額：18900 老牛執行了1300，當前餘額：20200 胖子執行了800，當前餘額：21000 王五執行了2700，當前餘額：18300

運行結果二：

張三執行了2000，當前餘額：12000 王五執行了2700，當前餘額：14700 老張執行了600，當前餘額：15300 老牛執行了1300，當前餘額：16600 胖子執行了800，當前餘額：17400 李四執行了3600，當前餘額：21000

運行結果三：

張三執行了2000，當前餘額：12000 王五執行了2700，當前餘額：18300 老張執行了600，當前餘額：18900 老牛執行了1300，當前餘額：20200 胖子執行了800，當前餘額：21000 李四執行了3600，當前餘額：15600

從運行結果能夠看出，雖然使用了原子量，可是程序併發訪問仍是有問題，那究竟問題出在哪裏了？

這裏要注意的一點是，原子量雖然能夠保證單個變量在某一個操做過程的安全，但沒法保證你整個代碼塊，或者整個程序的安全性。所以，一般還應該使用鎖等同步機制來控制整個程序的安全性。

下面是對上述代碼的修正：

package MultiThread; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * Java線程：併發庫-原子量 * * */ public class Test { public static void main(String[] args) { ExecutorService pool = Executors.newFixedThreadPool(2); Lock lock=new ReentrantLock(); Runnable t1 = new MyRunnable("張三", 2000,lock); Runnable t2 = new MyRunnable("李四", 3600,lock); Runnable t3 = new MyRunnable("王五", 2700,lock); Runnable t4 = new MyRunnable("老張", 600,lock); Runnable t5 = new MyRunnable("老牛", 1300,lock); Runnable t6 = new MyRunnable("胖子", 800,lock); //執行各個線程  pool.execute(t1); pool.execute(t2); pool.execute(t3); pool.execute(t4); pool.execute(t5); pool.execute(t6); //關閉線程池  pool.shutdown(); } } class MyRunnable implements Runnable { private static AtomicLong aLong = new AtomicLong(10000); //原子量，每一個線程均可以自由操做 private String name; //操做人 private int x; //操做數額 private Lock lock; MyRunnable(String name, int x,Lock lock) { this.name = name; this.x = x; this.lock=lock; } public void run() { lock.lock(); System.out.println(name + "執行了" + x + "，當前餘額：" + aLong.addAndGet(x)); lock.unlock(); } }

運行結果：

張三執行了2000，當前餘額：12000
李四執行了3600，當前餘額：15600 王五執行了2700，當前餘額：18300 老張執行了600，當前餘額：18900 老牛執行了1300，當前餘額：20200 胖子執行了800，當前餘額：21000

這裏使用了一個對象鎖，來控制對併發代碼的訪問。無論運行多少次，執行次序如何，最終餘額均爲21000，這個結果是正確的。

有關原子量的用法很簡單，關鍵是對原子量的認識，原子僅僅是保證變量操做的原子性，但整個程序還須要考慮線程安全的。

9、障礙器

Java5中，添加了障礙器類，爲了適應一種新的設計需求，好比一個大型的任務，經常須要分配好多子任務去執行，只有當全部子任務都執行完成時候，才能執行主任務，這時候，就能夠選擇障礙器了。障礙器是多線程併發控制的一種手段，用法很簡單。

下面給個例子：

package MultiThread; import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; /** * Java線程：新特徵-障礙器 * * */ public class Test { public static void main(String[] args) { //建立障礙器，並設置MainTask爲全部定數量的線程都達到障礙點時候所要執行的任務(Runnable) CyclicBarrier cb = new CyclicBarrier(7, new MainTask()); new SubTask("A", cb).start(); new SubTask("B", cb).start(); new SubTask("C", cb).start(); new SubTask("D", cb).start(); new SubTask("E", cb).start(); new SubTask("F", cb).start(); new SubTask("G", cb).start(); } } /** * 主任務 */ class MainTask implements Runnable { public void run() { System.out.println(">>>>主任務執行了！<<<<"); } } /** * 子任務 */ class SubTask extends Thread { private String name; private CyclicBarrier cb; SubTask(String name, CyclicBarrier cb) { this.name = name; this.cb = cb; } public void run() { System.out.println("[子任務" + name + "]開始執行了！"); for (int i = 0; i < 999999; i++) ; //模擬耗時的任務 System.out.println("[子任務" + name + "]開始執行完成了，並通知障礙器已經完成！"); try { //通知障礙器已經完成，讓出鎖（並使得，跳躍的障礙數目-1）  cb.await(); } catch (InterruptedException e) { e.printStackTrace(); } catch (BrokenBarrierException e) { e.printStackTrace(); } } }

運行結果：

[子任務B]開始執行了！
[子任務E]開始執行了！
[子任務C]開始執行了！
[子任務D]開始執行了！
[子任務A]開始執行了！
[子任務E]開始執行完成了，並通知障礙器已經完成！
[子任務B]開始執行完成了，並通知障礙器已經完成！
[子任務A]開始執行完成了，並通知障礙器已經完成！
[子任務C]開始執行完成了，並通知障礙器已經完成！
[子任務D]開始執行完成了，並通知障礙器已經完成！
[子任務F]開始執行了！
[子任務F]開始執行完成了，並通知障礙器已經完成！
[子任務G]開始執行了！
[子任務G]開始執行完成了，並通知障礙器已經完成！
>>>>主任務執行了！<<<<

從執行結果能夠看出，全部子任務完成的時候，主任務執行了，達到了控制的目標