我們都知道，在JDK1.5之前，Java中要進行業務并發時，通常需要有程序員獨立完成代碼實現，當然也有一些開源的框架提供了這些功能，但是這些依然沒有JDK自帶的功能使用起來方便。而當針對高質量Java多線程并發程序設計時,為防止死蹦等現象的出現，比如使用java之前的wait()、notify()和synchronized等，每每需要考慮性能、死鎖、公平性、資源管理以及如何避免線程安全性方面帶來的危害等諸多因素，往往會采用一些較為復雜的安全策略，加重了程序員的開發負擔.萬幸的是，在JDK1.5出現之后，Sun大神（Doug Lea）終于為我們這些可憐的小程序員推出了java.util.concurrent工具包以簡化并發完成。開發者們借助于此，將有效的減少競爭條件（race conditions）和死鎖線程。concurrent包很好的解決了這些問題，為我們提供了更實用的并發程序模型。

Executor                 ：具體Runnable任務的執行者。
ExecutorService          ：一個線程池管理者，其實現類有多種，我會介紹一部分。我們能把Runnable,Callable提交到池中讓其調度。
Semaphore                ：一個計數信號量
ReentrantLock            ：一個可重入的互斥鎖定 Lock，功能類似synchronized，但要強大的多。
Future                   ：是與Runnable,Callable進行交互的接口，比如一個線程執行結束后取返回的結果等等，還提供了cancel終止線程。
BlockingQueue            ：阻塞隊列。
CompletionService        : ExecutorService的擴展，可以獲得線程執行結果的
CountDownLatch           ：一個同步輔助類，在完成一組正在其他線程中執行的操作之前，它允許一個或多個線程一直等待。
CyclicBarrier            ：一個同步輔助類，它允許一組線程互相等待，直到到達某個公共屏障點
Future                   ：Future 表示異步計算的結果。
ScheduledExecutorService ：一個 ExecutorService，可安排在給定的延遲后運行或定期執行的命令。

接下來逐一介紹

Executors主要方法說明
newFixedThreadPool（固定大小線程池）
創建一個可重用固定線程集合的線程池，以共享的無界隊列方式來運行這些線程（只有要請求的過來，就會在一個隊列里等待執行）。如果在關閉前的執行期間由于失敗而導致任何線程終止，那么一個新線程將代替它執行后續的任務（如果需要）。

newCachedThreadPool（無界線程池，可以進行自動線程回收）
創建一個可根據需要創建新線程的線程池，但是在以前構造的線程可用時將重用它們。對于執行很多短期異步任務的程序而言，這些線程池通常可提高程序性能。調用 execute 將重用以前構造的線程（如果線程可用）。如果現有線程沒有可用的，則創建一個新線程并添加到池中。終止并從緩存中移除那些已有 60 秒鐘未被使用的線程。因此，長時間保持空閑的線程池不會使用任何資源。注意，可以使用 ThreadPoolExecutor 構造方法創建具有類似屬性但細節不同（例如超時參數）的線程池。

newSingleThreadExecutor（單個后臺線程）
創建一個使用單個 worker 線程的 Executor，以無界隊列方式來運行該線程。（注意，如果因為在關閉前的執行期間出現失敗而終止了此單個線程，那么如果需要，一個新線程將代替它執行后續的任務）。可保證順序地執行各個任務，并且在任意給定的時間不會有多個線程是活動的。與其他等效的 newFixedThreadPool(1) 不同，可保證無需重新配置此方法所返回的執行程序即可使用其他的線程。

這些方法返回的都是ExecutorService對象，這個對象可以理解為就是一個線程池。
這個線程池的功能還是比較完善的。可以提交任務submit()可以結束線程池shutdown()。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MyExecutor extends Thread {
private int index;
public MyExecutor(int i){
   this.index=i;
}
public void run(){
   try{
    System.out.println("["+this.index+"] start....");
    Thread.sleep((int)(Math.random()*1000));
    System.out.println("["+this.index+"] end.");
   }
   catch(Exception e){
    e.printStackTrace();
   }
}

public static void main(String args[]){
   ExecutorService service=Executors.newFixedThreadPool(4);
   for(int i=0;i<10;i++){
    service.execute(new MyExecutor(i));
    //service.submit(new MyExecutor(i));
   }
   System.out.println("submit finish");
   service.shutdown();
}
}

雖然打印了一些信息，但是看的不是非常清晰，這個線程池是如何工作的，我們來將休眠的時間調長10倍。
Thread.sleep((int)(Math.random()*10000));

再來看，會清楚看到只能執行4個線程。當執行完一個線程后，才會又執行一個新的線程，也就是說，我們將所有的線程提交后，線程池會等待執行完最后shutdown。我們也會發現，提交的線程被放到一個“無界隊列里”。這是一個有序隊列（BlockingQueue，這個下面會說到）。

另外它使用了Executors的靜態函數生成一個固定的線程池，顧名思義，線程池的線程是不會釋放的，即使它是Idle。
這就會產生性能問題，比如如果線程池的大小為200，當全部使用完畢后，所有的線程會繼續留在池中，相應的內存和線程切換（while(true)+sleep循環）都會增加。
如果要避免這個問題，就必須直接使用ThreadPoolExecutor()來構造。可以像通用的線程池一樣設置“最大線程數”、“最小線程數”和“空閑線程keepAlive的時間”。

這個就是線程池基本用法。

Semaphore
一個計數信號量。從概念上講，信號量維護了一個許可集合。如有必要，在許可可用前會阻塞每一個 acquire()，然后再獲取該許可。每個 release() 添加一個許可，從而可能釋放一個正在阻塞的獲取者。但是，不使用實際的許可對象，Semaphore 只對可用許可的號碼進行計數，并采取相應的行動。

Semaphore 通常用于限制可以訪問某些資源（物理或邏輯的）的線程數目。例如，下面的類使用信號量控制對內容池的訪問：

這里是一個實際的情況，大家排隊上廁所，廁所只有兩個位置，來了10個人需要排隊。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class MySemaphore extends Thread {
Semaphore position;
private int id;
public MySemaphore(int i,Semaphore s){
   this.id=i;
   this.position=s;
}

public void run(){
   try{
    if(position.availablePermits()>0){
     System.out.println("顧客["+this.id+"]進入廁所，有空位");
    }
    else{
     System.out.println("顧客["+this.id+"]進入廁所，沒空位，排隊");
    }
    position.acquire();
    System.out.println("顧客["+this.id+"]獲得坑位");
    Thread.sleep((int)(Math.random()*1000));
    System.out.println("顧客["+this.id+"]使用完畢");
    position.release();
   }
   catch(Exception e){
    e.printStackTrace();
   }
}
public static void main(String args[]){
   ExecutorService list=Executors.newCachedThreadPool();
   Semaphore position=new Semaphore(2);
   for(int i=0;i<10;i++){
    list.submit(new MySemaphore(i+1,position));
   }
   list.shutdown();
   position.acquireUninterruptibly(2);
   System.out.println("使用完畢，需要清掃了");
   position.release(2);
}
}

 

ReentrantLock
一個可重入的互斥鎖定 Lock，它具有與使用 synchronized 方法和語句所訪問的隱式監視器鎖定相同的一些基本行為和語義，但功能更強大。

ReentrantLock 將由最近成功獲得鎖定，并且還沒有釋放該鎖定的線程所擁有。當鎖定沒有被另一個線程所擁有時，調用 lock 的線程將成功獲取該鎖定并返回。如果當前線程已經擁有該鎖定，此方法將立即返回。可以使用 isHeldByCurrentThread() 和 getHoldCount() 方法來檢查此情況是否發生。

此類的構造方法接受一個可選的公平參數。
當設置為 true時，在多個線程的爭用下，這些鎖定傾向于將訪問權授予等待時間最長的線程。否則此鎖定將無法保證任何特定訪問順序。
與采用默認設置（使用不公平鎖定）相比，使用公平鎖定的程序在許多線程訪問時表現為很低的總體吞吐量（即速度很慢，常常極其慢），但是在獲得鎖定和保證鎖定分配的均衡性時差異較小。不過要注意的是，公平鎖定不能保證線程調度的公平性。因此，使用公平鎖定的眾多線程中的一員可能獲得多倍的成功機會，這種情況發生在其他活動線程沒有被處理并且目前并未持有鎖定時。還要注意的是，未定時的 tryLock 方法并沒有使用公平設置。因為即使其他線程正在等待，只要該鎖定是可用的，此方法就可以獲得成功。

建議總是 立即實踐，使用 try 塊來調用 lock，在之前/之后的構造中，最典型的代碼如下：
class X {
   private final ReentrantLock lock = new ReentrantLock();
   // ...

   public void m() {
     lock.lock(); // block until condition holds
     try {
       // ... method body
     } finally {
       lock.unlock()
     }
   }
}

我的例子：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantLock;

public class MyReentrantLock extends Thread{
TestReentrantLock lock;
private int id;
public MyReentrantLock(int i,TestReentrantLock test){
   this.id=i;
   this.lock=test;
}

public void run(){
   lock.print(id);
}

public static void main(String args[]){
   ExecutorService service=Executors.newCachedThreadPool();
   TestReentrantLock lock=new TestReentrantLock();
   for(int i=0;i<10;i++){
    service.submit(new MyReentrantLock(i,lock));
   }
   service.shutdown();
}
}
class TestReentrantLock{
private ReentrantLock lock=new ReentrantLock();
public void print(int str){
   try{
    lock.lock();
    System.out.println(str+"獲得");
    Thread.sleep((int)(Math.random()*1000));
   }
   catch(Exception e){
    e.printStackTrace();
   }
   finally{
    System.out.println(str+"釋放");
    lock.unlock();
   }
}
}