第一節 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
