第一節 CountDownLatch （1）初識CountDownLatch （2）詳述CountDownLatch CountDownLatch是通過一個計數器來實現的，計數器的初始值為線程的數量。每當一個線程完成了自己的任務後，計數器的值就會減1，當計數器值到達0時，它表示所有的線程已經完成了任 ...
第一節 CountDownLatch
（1）初識CountDownLatch
（2）詳述CountDownLatch
CountDownLatch是通過一個計數器來實現的，計數器的初始值為線程的數量。每當一個線程完成了自己的任務後，計數器的值就會減1，當計數器值到達0時，它表示所有的線程已經完成了任務，然後在閉鎖上等待的線程就可以恢復執行任務。
CountDownLatch中主要方法如下：
public CountDownLatch(int count)，構造函數中的count（計數器）實際上就是閉鎖需要等待的線程數量，這個值只能被設置一次，而且CountDownLatch沒有提供任何機制去重新設置這個計數值。
public void countDown()，每調用一次這個方法，在構造函數中初始化的count值就減1，通知機制是此方法來完成的。
public void await() throws InterruptedException，調用此方法的當前線程會一直阻塞，直到計時器的值為0。
（3）CountDownLatch示例
package com.test; import java.util.concurrent.CountDownLatch; public class CountDownLatchDemo{ public static void main(String args[]) throws Exception{ CountDownLatch latch = new CountDownLatch(3); Worker worker1 = new Worker("Jack 程式員1",latch); Worker worker2 = new Worker("Rose 程式員2",latch); Worker worker3 = new Worker("Json 程式員3",latch); worker1.start(); worker2.start(); worker3.start(); latch.await(); System.out.println("Main thread end!"); } static class Worker extends Thread { private String workerName; private CountDownLatch latch; public Worker(String workerName,CountDownLatch latch) { this.workerName = workerName; this.latch = latch; } @Override public void run() { try { System.out.println("Worker:"+workerName +" is begin."); Thread.sleep(1000L); System.out.println("Worker:"+workerName +" is end."); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); }//模仿幹活； latch.countDown(); } } }
上述程式運行結果如下：
Worker:Rose 程式員2 is begin.
Worker:Json 程式員3 is begin.
Worker:Jack 程式員1 is begin.
Worker:Jack 程式員1 is end.
Worker:Json 程式員3 is end.
Worker:Rose 程式員2 is end.
Main thread end!
從結果上可以看出，MainThread執行到latch.await();處會阻塞在該處，直到三個線程均完成的時候MainThread才會繼續往下執行
（4）參考資料
本小節只是簡單描述了CountDownLatch的使用方式等，欲瞭解其實現機制，可以查看下麵的幾篇文章
A、http://blog.itpub.net/30024515/viewspace-1432825/
B、http://www.tuicool.com/articles/mQnAfq
第二節 CyclicBarrier
（1）初識CyclicBarrier
（2）CyclicBarrier示例
應用場景：在某種需求中，比如一個大型的任務，常常需要分配很多子任務去執行，只有當所有子任務都執行完成時候，才能執行主任務，這時候就可以選擇CyclicBarrier了。
示例：
package com.test; import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; public class CyclicBarrierDemo{ public static void main(String args[]) throws Exception{ CyclicBarrier barrier = new CyclicBarrier(3,new TotalTask()); BillTask worker1 = new BillTask("111",barrier); BillTask worker2 = new BillTask("222",barrier); BillTask worker3 = new BillTask("333",barrier); worker1.start(); worker2.start(); worker3.start(); System.out.println("Main thread end!"); } static class TotalTask extends Thread { public void run() { System.out.println("所有子任務都執行完了，就開始執行主任務了。"); } } static class BillTask extends Thread { private String billName; private CyclicBarrier barrier; public BillTask(String workerName,CyclicBarrier barrier) { this.billName = workerName; this.barrier = barrier; } @Override public void run() { try { System.out.println("市區:"+billName +"運算開始："); Thread.sleep(1000L);//模仿第一次運算； System.out.println("市區:"+billName +"運算完成，等待中..."); barrier.await();//假設一次運算不完，第二次要依賴第一次的運算結果。都到達這個節點之後後面才會繼續執行； System.out.println("全部都結束，市區"+billName +"才開始後面的工作。"); } catch (InterruptedException e) { e.printStackTrace(); } catch (BrokenBarrierException e) { e.printStackTrace(); } } } }
上述程式運行結果如下：
市區:111運算開始：
市區:333運算開始：
Main thread end!
市區:222運算開始：
市區:333運算完成，等待中...
市區:222運算完成，等待中...
市區:111運算完成，等待中...
所有子任務都執行完了，就開始執行主任務了。//這句話是最後到達wait()方法的那個線程執行的
全部都結束，市區111才開始後面的工作。
全部都結束，市區222才開始後面的工作。
全部都結束，市區333才開始後面的工作。
解說：在這個示例中，構造CyclicBarrier時，傳入了內部類TotalTask（TotalTask繼承了Thread，是Runnable的實現）的實例對象，其意義在於：當所有的線程都執行到wait()方法時，它們會一起返回繼續自己的工作，但是最後一個到達wait()方法的線程會執行TotalTask的run()方法；如果在構造構造CyclicBarrier時沒有傳入Runnable的實現對象作為構造參數，則當所有的線程都執行到wait()方法時會直接一起返回繼續自己的工作。
（3）CyclicBarrier與CountDownLatch的區別
A、CountDownLatch的作用是允許1或N個線程等待其他線程完成執行；而CyclicBarrier則是允許N個線程相互等待；
B、CountDownLatch的計數器無法被重置；而CyclicBarrier的計數器可以被重置後使用，因此它被稱為是迴圈的barrier。
第三節 Semaphore
（1）初識Semaphore
Java中的Semaphore用於線上程間傳遞信號，從概念上講，信號量維護了一個許可集合，Semaphore只對可用的許可進行計數，並採取相應的行動。信號量常常用於多線程的代碼中，比如資料庫連接池。
（2）Semaphore示例
場景：假設一個伺服器資源有限，任意某一時刻只允許3個人同時進行訪問，這時一共來了10個人
package com.test; import java.util.concurrent.Semaphore; public class SemaphoreDemo{ public static void main(String args[]) throws Exception{ final Semaphore semaphore = new Semaphore(3);//一次只運行3個人進行訪問 for(int i=0;i<10;i++) { final int no = i; Runnable thread = new Runnable() { public void run (){ try { System.out.println("用戶"+no+"連接上了:"); Thread.sleep(300L); semaphore.acquire();//獲取接下去執行的許可 System.out.println("用戶"+no+"開始訪問後臺程式..."); Thread.sleep(1000L);//模仿用戶訪問服務過程 semaphore.release();//釋放允許下一個線程訪問進入後臺 System.out.println("用戶"+no+"訪問結束。"); } catch (InterruptedException e) { e.printStackTrace(); } } }; new Thread(thread).start(); } System.out.println("Main thread end!"); } }
上述代碼運行結果如下：
用戶1連接上了: 用戶3連接上了: 用戶4連接上了: 用戶2連接上了: 用戶0連接上了: 用戶5連接上了: 用戶7連接上了: Main thread end! 用戶6連接上了: 用戶8連接上了: 用戶9連接上了: 用戶3開始訪問後臺程式... 用戶4開始訪問後臺程式... 用戶2開始訪問後臺程式... 用戶4訪問結束。 用戶3訪問結束。 用戶7開始訪問後臺程式... 用戶0開始訪問後臺程式... 用戶8開始訪問後臺程式... 用戶2訪問結束。 用戶5開始訪問後臺程式... 用戶0訪問結束。 用戶7訪問結束。 用戶1開始訪問後臺程式... 用戶8訪問結束。 用戶6開始訪問後臺程式... 用戶1訪問結束。 用戶9開始訪問後臺程式... 用戶5訪問結束。 用戶6訪問結束。 用戶9訪問結束。
從結果上可以看出來，10個人同時進來，但是只能同時3個人訪問資源，釋放一個允許進來一個
（3）參考資料
http://ifeve.com/semaphore/
第四節 Exchanger
（1）初識Exchanger
此處的Exechanger與前面描述的幾個同步機制不一樣，前面描述的幾個同步機制均是通過計數器來實現的，下麵簡單描述一下Exechanger，看看Exchanger的應用場景：
註意：從上文描述，我們知道Exchanger用於在成對出現的線程之間（兩個線程共有一個Exchanger）交換數據
（2）Exechanger示例
（3）參考資料
http://www.cnblogs.com/davidwang456/p/4179488.html
