http://heipark.iteye.com/blog/1393847

newFixedThreadPool內部有個任務佇列，假設執行緒池裡有3個執行緒，提交了5個任務，那麼後兩個任務就放在任務隊列了，即使前3個任務sleep或者堵塞了，也不會執行後兩個任務，除非前三個任務有執行完的

newFixedThreadPool使用範例：

Java程式碼  

1. import java.io.IOException;  
2. import java.util.concurrent.ExecutorService;  
3. import java.util.concurrent.Executors;  
4. public class Test {  
5.     public static void main(String[] args) throws IOException, InterruptedException {  
6.         ExecutorService service = Executors.newFixedThreadPool(2);  
7.         for (int i = 0; i < 6; i++) {  
8.             final int index = i;  
9.             System.out.println("task: " + (i+1
   ));  
10.             Runnable run = new Runnable() {  
11.                 @Override  
12.                 public void run() {  
13.                     System.out.println("thread start" + index);  
14.                     try {  
15.                         Thread.sleep(Long.MAX_VALUE);  
16.                     } catch (InterruptedException e) {  
17.                         e.printStackTrace();  
18.                     }  
19.                     System.out.println("thread end" + index);  
20.                 }  
21.             };  
22.             service.execute(run);  
23.         }  
24.     }  
25. }  

 輸出： task: 1
task: 2
thread start0
task: 3
task: 4
task: 5
task: 6
task: 7
thread start1
task: 8
task: 9
task: 10
task: 11
task: 12
task: 13
task: 14
task: 15

    從例項可以看到for迴圈並沒有被固定的執行緒池阻塞住，也就是說所有的執行緒task都被提交到了ExecutorService中，檢視 Executors.newFixedThreadPool()如下：

public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}

    可以看到task被提交都了LinkedBlockingQueue中。這裡有個問題，如果任務列表很大，一定會把記憶體撐爆，如何解決？看下面：

Java程式碼  

1. import java.io.IOException;  
2. import java.util.concurrent.ArrayBlockingQueue;  
3. import java.util.concurrent.BlockingQueue;  
4. import java.util.concurrent.ThreadPoolExecutor;  
5. import java.util.concurrent.TimeUnit;  
6. public class Test {  
7.     public static void main(String[] args) throws IOException, InterruptedException {  
8.         BlockingQueue<Runnable> queue = new ArrayBlockingQueue<Runnable>(3);  
9.         ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 3, 1, TimeUnit.HOURS, queue, new ThreadPoolExecutor.CallerRunsPolicy());  
10.         for (int i = 0; i < 10; i++) {  
11.             final int index = i;  
12.             System.out.println("task: " + (index+1));  
13.             Runnable run = new Runnable() {  
14.                 @Override  
15.                 public void run() {  
16.                     System.out.println("thread start" + (index+1));  
17.                     try {  
18.                         Thread.sleep(Long.MAX_VALUE);  
19.                     } catch (InterruptedException e) {  
20.                         e.printStackTrace();  
21.                     }  
22.                     System.out.println("thread end" + (index+1));  
23.                 }  
24.             };  
25.             executor.execute(run);  
26.         }  
27.     }  
28. }  

 輸出： task: 1
task: 2
thread start1
task: 3
task: 4
task: 5
task: 6
task: 7
thread start2
thread start7
thread start6

    執行緒池最大值為4（？？這裡我不明白為什麼是設定值+1，即3+1，而不是3），準備執行的任務佇列為3。可以看到for迴圈先處理4個task，然後把3個放到佇列。這樣就實現了自動阻塞佇列的效果。記得要使用ArrayBlockingQueue這個佇列，然後設定容量就OK了。