Java並發包中的幾種ExecutorService

1.CachedThreadPool

CachedThreadPool首先會按照需要創建足夠多的線程來執行任務(Task)。隨著程序執行的過程，有的線程執行完了任務，可以被重新循環使用時，才不再創建新的線程來執行任務。我們采用《Thinking In Java》中的例子來分析。

首先，任務定義如下(實現了Runnable接口，並且復寫了run方法)：

1. package net.jerryblog.concurrent;
2. public class LiftOff implements Runnable{
3. protected int countDown = 10; //Default
4. private static int taskCount = 0;
5. private final int id = taskCount++;
6. public LiftOff() {}
7. public LiftOff(int countDown) {
8. this.countDown = countDown;
9. }
10. public String status() {
11. return "#" + id + "(" +
12. (countDown > 0 ? countDown : "LiftOff!") + ") ";
13. }
14. @Override
15. public void run() {
16. while(countDown-- > 0) {
17. System.out.print(status());
18. Thread.yield();
19. }
21. }
22. }

采用CachedThreadPool方式執行編寫的客戶端程序如下：

1. package net.jerryblog.concurrent;
2. import java.util.concurrent.ExecutorService;
3. import java.util.concurrent.Executors;
4. public class CachedThreadPool {
5. public static void main(String[] args) {
6. ExecutorService exec = Executors.newCachedThreadPool();
7. for(int i = 0; i < 10; i++) {
8. exec.execute(new LiftOff());
9. }
10. exec.shutdown();
11. }
12. }

上面的程序中，有10個任務，采用CachedThreadPool模式，exec沒遇到一個LiftOff的對象(Task)，就會創建一個線程來處理任務。現在假設遇到到第4個任務時，之前用於處理第一個任務的線程已經執行完成任務了，那麼不會創建新的線程來處理任務，而是使用之前處理第一個任務的線程來處理這第4個任務。接著如果遇到第5個任務時，前面那些任務都還沒有執行完，那麼就會又新創建線程來執行第5個任務。否則，使用之前執行完任務的線程來處理新的任務。