前面幾篇部落格寫到的多執行緒實現基本都是顯式呼叫了Thread的start()方法，除了這種方法有沒有其他的實現方法呢，這裡我們來看下java.util.concurrent包下的ExecutorService實現。

看一個簡單的例子： 

public class ThreadTest {
	
	public static void main(String[] args) {
		ExecutorService executorService = Executors.newFixedThreadPool(10);
		executorService.execute(new Runnable() {
			public void run() {
				System.out.println("Asynchronous task");
			}
		});
		
		executorService.shutdown();
	}
}
 

這個例子其實很容易看懂，首先使用newFixedThreadPool() 工廠方法建立一個 ExecutorService ，上述程式碼建立了一個可以容納10個執行緒任務的執行緒池。然後向execute() 方法中傳遞一個非同步的 Runnable 介面的實現，這樣做會讓 ExecutorService 中的某個執行緒執行這個 Runnable執行緒。

由此可以看出ExecutorService使用執行緒池來管理執行緒，可以重複利用已經創建出來的執行緒而不是每次都必須新建立執行緒，節省了一部分的開銷。執行緒池可以很方便的管理執行緒的大小和當前在執行的執行緒數量。

		ExecutorService executorService1 = Executors.newSingleThreadExecutor();
		ExecutorService executorService2 = Executors.newFixedThreadPool(10);
		ExecutorService executorService3 = Executors.newScheduledThreadPool(10);

package java.util.concurrent;
import java.util.List;
import java.util.Collection;


public interface ExecutorService extends Executor {
   
    void shutdown();
    
    List<Runnable> shutdownNow();
    
    boolean isShutdown();
   
    boolean isTerminated();
    
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;
   
    <T> Future<T> submit(Callable<T> task);
    
    <T> Future<T> submit(Runnable task, T result);
    
    Future<?> submit(Runnable task);

    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;

    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;

    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;

    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}
 

這裡有幾種不同的方式讓你將任務委託給一個ExecutorService：

1   execute(Runnable)
2   submit(Runnable)
3   submit(Callable)
4   invokeAny(...)
5   invokeAll(...)

execute(Runnable)

方法 execute(Runnable)接收一個 java.lang.Runnable 物件作為引數，並且以非同步的方式執行它。如下是一個使用 ExecutorService 執行 Runnable的例子：

	ExecutorService executorService =Executors.newSingleThreadExecutor();
		   
	executorService.execute(newRunnable() {
	       public void run() {
	          System.out.println("Asynchronous task");
	       }
        });
		       
	executorService.shutdown();

使用這種方式沒有辦法獲取執行 Runnable之後的結果，如果你希望獲取執行之後的返回值，就必須使用 接收 Callable 引數的 execute() 方法，後者將會在下文中提到。

submit(Runnable)

方法 submit(Runnable)同樣接收一個 Runnable 的實現作為引數，但是會返回一個 Future 物件。這個 Future 物件可以用於判斷 Runnable是否結束執行。如下是一個 ExecutorService 的 submit() 方法的例子：

	   Future future = executorService.submit(new Runnable() {
		   public void run() {
			   System.out.println("Asynchronous task");
		   }
	   });
	   //如果任務結束執行則返回 null
	   System.out.println("future.get()=" + future.get());

submit(Callable)

方法 submit(Callable) 和方法submit(Runnable) 比較類似，但是區別則在於它們接收不同的引數型別。Callable 的例項與 Runnable 的例項很類似，但是Callable 的 call() 方法可以返回一個結果。方法 Runnable.run() 則不能返回結果。

Callable 的返回值可以從方法submit(Callable) 返回的 Future 物件中獲取。如下是一個 ExecutorService Callable 的樣例：

	   Future future = executorService.submit(newCallable(){
		   public Object call() throwsException {
			   System.out.println("AsynchronousCallable");
			   return "CallableResult";
		   }
	   });
	   System.out.println("future.get()= " + future.get());

上述樣例程式碼會輸出如下結果：

Asynchronous Callable
future.get() = Callable Result

inVokeAny()

方法 invokeAny() 接收一個包含Callable 物件的集合作為引數。呼叫該方法不會返回 Future 物件，而是返回集合中某一個 Callable物件的結果，而且無法保證呼叫之後返回的結果是哪一個 Callable，只知道它是這些 Callable 中一個執行結束的 Callable 物件。

如果一個任務執行完畢或者丟擲異常，方法會取消其它的Callable 的執行。

以下是一個樣例：

	   Future future = executorService.submit(newCallable(){
		   public Object call() throwsException {
			   System.out.println("AsynchronousCallable");
			   return "CallableResult";
		   }
	   });
	   System.out.println("future.get()= " + future.get());
	   
	   ExecutorService executorService =Executors.newSingleThreadExecutor();
	   Set<Callable<String>>callables = new HashSet<Callable<String>>();
	   callables.add(newCallable<String>() {
		   public String call() throwsException {
			   return "Task1";
		   }
	   });
	   callables.add(newCallable<String>() {
		   public String call() throwsException {
			   return "Task2";
		   }
	   });
	   callables.add(newCallable<String>() {
		   public String call() throwsException {
			   return "Task3";
		   }
	   });
	   String result =executorService.invokeAny(callables);
	   System.out.println("result =" + result);
	   executorService.shutdown();

以上樣例程式碼會打印出在給定的集合中的某一個Callable 的返回結果。我嘗試運行了幾次，結果都在改變。有時候返回結果是”Task 1”，有時候是”Task 2”，等等。

invokeAll()

方法 invokeAll()會呼叫存在於引數集合中的所有 Callable 物件，並且返回一個包含 Future 物件的集合，你可以通過這個返回的集合來管理每個 Callable的執行結果。

需要注意的是，任務有可能因為異常而導致執行結束，所以它可能並不是真的成功運行了。但是我們沒有辦法通過Future 物件來了解到這個差異。

以下是一個程式碼樣例：

	   ExecutorService executorService =Executors.newSingleThreadExecutor();

	   Set<Callable<String>>callables = new HashSet<Callable<String>>();
	   
	   callables.add(newCallable<String>() {
		   public String call() throwsException {
			   return "Task1";
		   }
	   });
	   callables.add(newCallable<String>() {
		   public String call() throwsException {
			   return "Task2";
		   }
	   });
	   callables.add(newCallable<String>() {
		   public String call() throwsException {
			   return "Task3";
		   }
	   });
	     
	   List<Future<String>>futures = executorService.invokeAll(callables);
	    
	   for(Future<String> future :futures){
		   System.out.println("future.get = " +future.get());
	   }
	     
	   executorService.shutdown();

ExecuteService 服務的關閉

當使用 ExecutorService完畢之後，我們應該關閉它，這樣才能保證執行緒不會繼續保持執行狀態。

舉例來說，如果你的程式通過 main()方法啟動，並且主執行緒退出了你的程式，如果你還有一個活動的 ExecutorService 存在於你的程式中，那麼程式將會繼續保持執行狀態。存在於ExecutorService 中的活動執行緒會阻止Java虛擬機器關閉。

為了關閉在 ExecutorService中的執行緒，你需要呼叫 shutdown() 方法。ExecutorService並不會馬上關閉，而是不再接收新的任務，壹但所有的執行緒結束執行當前任務，ExecutorServie 才會真的關閉。所有在呼叫 shutdown()方法之前提交到 ExecutorService 的任務都會執行。

如果你希望立即關閉ExecutorService，你可以呼叫 shutdownNow()方法。這個方法會嘗試馬上關閉所有正在執行的任務，並且跳過所有已經提交但是還沒有執行的任務。但是對於正在執行的任務，是否能夠成功關閉它是無法保證的，有可能他們真的被關閉掉了，也有可能它會壹直執行到任務結束。這是一個最好的嘗試。