ExecutorService的submit方法使用

在Java5之后，並發線程這塊發生了根本的變化，最重要的莫過於新的啟動、調度、管理線程的一大堆API了。在Java5以后，通過Executor來啟動線程比用Thread的start()更好。在新特征中，可以很容易控制線程的啟動、執行和關閉過程，還可以很容易使用線程池的特性。

 

一、創建任務

 

任務就是一個實現了Runnable接口的類。

創建的時候實run方法即可。

 

二、執行任務

 

通過java.util.concurrent.ExecutorService接口對象來執行任務，該接口對象通過工具類java.util.concurrent.Executors的靜態方法來創建。

 

Executors此包中所定義的 Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 類的工廠和實用方法。

 

ExecutorService提供了管理終止的方法，以及可為跟蹤一個或多個異步任務執行狀況而生成 Future 的方法。 可以關閉 ExecutorService，這將導致其停止接受新任務。關閉后，執行程序將最后終止，這時沒有任務在執行，也沒有任務在等待執行，並且無法提交新任務。

            executorService.execute(new TestRunnable());

 

1、創建ExecutorService

通過工具類java.util.concurrent.Executors的靜態方法來創建。

Executors此包中所定義的 Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 類的工廠和實用方法。

 

比如，創建一個ExecutorService的實例，ExecutorService實際上是一個線程池的管理工具：

        ExecutorService executorService = Executors.newCachedThreadPool();

        ExecutorService executorService = Executors.newFixedThreadPool(3);

        ExecutorService executorService = Executors.newSingleThreadExecutor();

 

2、將任務添加到線程去執行

當將一個任務添加到線程池中的時候，線程池會為每個任務創建一個線程，該線程會在之后的某個時刻自動執行。

 

三、關閉執行服務對象

        executorService.shutdown();

四、獲取任務的執行的返回值

在Java5之后，任務分兩類：一類是實現了Runnable接口的類，一類是實現了Callable接口的類。兩者都可以被ExecutorService執行，但是Runnable任務沒有返回值，而Callable任務有返回值。並且Callable的call()方法只能通過ExecutorService的(<T> task)  方法來執行，並且返回一個 <T><T>，是表示任務等待完成的 Future。

 

public interface  Callable<V>

返回結果並且可能拋出異常的任務。實現者定義了一個不帶任何參數的叫做  call 的方法。

Callable 接口類似於，兩者都是為那些其實例可能被另一個線程執行的類設計的。但是  Runnable 不會返回結果，並且無法拋出經過檢查的異常。

類包含一些從其他普通形式轉換成  Callable 類的實用方法。

 

 

Callable中的call()方法類似Runnable的run()方法，就是前者有返回值，后者沒有。

 

當將一個Callable的對象傳遞給ExecutorService的submit方法，則該call方法自動在一個線程上執行，並且會返回執行結果Future對象。

 

同樣，將Runnable的對象傳遞給ExecutorService的submit方法，則該run方法自動在一個線程上執行，並且會返回執行結果Future對象，但是在該Future對象上調用get方法，將返回null。

五、ExecutorService的execute和submit方法區別,以及submit使用的具體Demo

1、接收的參數不一樣

2、submit有返回值，而execute沒有

Method submit extends base method Executor.execute by creating and returning a Future that can be used to cancel execution and/or wait for completion. 

用到返回值的例子，比如說我有很多個做validation的task，我希望所有的task執行完，然后每個task告訴我它的執行結果，是成功還是失敗，如果是失敗，原因是什么。然后我就可以把所有失敗的原因綜合起來發給調用者。

個人覺得cancel execution這個用處不大，很少有需要去取消執行的。

而最大的用處應該是第二點。

3、submit方便Exception處理

There is a difference when looking at exception handling. If your tasks throws an exception and if it was submitted with execute this exception will Go to the uncaught exception handler (when you don't have provided one explicitly, the default one will just print the stack trace to System.err). If you submitted the task with submit any thrown exception, checked or not, is then part of the task's return status. For a task that was submitted with submit and that terminates with an exception, the Future.get will rethrow this exception, wrapped in an ExecutionException.

意思就是如果你在你的task里會拋出checked或者unchecked exception，而你又希望外面的調用者能夠感知這些exception並做出及時的處理，那么就需要用到submit，通過捕獲Future.get拋出的異常。

 

比如說，我有很多更新各種數據的task，我希望如果其中一個task失敗，其它的task就不需要執行了。那我就需要catch Future.get拋出的異常，然后終止其它task的執行，代碼如下：

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.*;

/**
 * Created by caoliu on 2017/8/18.
 */
public class ExecutorServiceTest {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        List<Future<String>> resultList = new ArrayList<>();

        // 創建10個任務並執行
        for (int i = 0; i < 10; i++) {
            // 使用ExecutorService執行Callable類型的任務，並將結果保存在future變量中
            Future<String> future = executorService.submit(new TaskWithResult(i));
            // 將任務執行結果存儲到List中
            resultList.add(future);
        }
        executorService.shutdown();

        // 遍歷任務的結果
        for (Future<String> fs : resultList) {
            try {
                System.out.println(fs.get()); // 打印各個線程（任務）執行的結果
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                executorService.shutdownNow();
                e.printStackTrace();
                return;
            }
        }
    }
}
class TaskWithResult implements Callable<String> {
    private int id;

    public TaskWithResult(int id) {
        this.id = id;
    }

    /**
     * 任務的具體過程，一旦任務傳給ExecutorService的submit方法，則該方法自動在一個線程上執行。
     *
     * @return
     * @throws Exception
     */
    public String call() throws Exception {
        System.out.println("call()方法被自動調用,干活！！！             " + Thread.currentThread().getName());
        //下面的判讀是模擬一個拋出異常的操作
        if (new Random().nextBoolean())
            throw new TaskException("Meet error in task." + Thread.currentThread().getName());
        // 一個模擬耗時的操作
        for (int i = 999999999; i > 0; i--)
            ;
        return "call()方法被自動調用，任務的結果是：" + id + "    " + Thread.currentThread().getName();
    }
}
class TaskException extends Exception {
    public TaskException(String message) {
        super(message);
    }
}

下面是控制台輸出的結果:

call()方法被自動調用,干活！！！             pool-1-thread-1
call()方法被自動調用,干活！！！             pool-1-thread-4
call()方法被自動調用,干活！！！             pool-1-thread-3
call()方法被自動調用,干活！！！             pool-1-thread-2
call()方法被自動調用,干活！！！             pool-1-thread-5
call()方法被自動調用,干活！！！             pool-1-thread-6
call()方法被自動調用,干活！！！             pool-1-thread-7
call()方法被自動調用,干活！！！             pool-1-thread-4
call()方法被自動調用,干活！！！             pool-1-thread-8
call()方法被自動調用,干活！！！             pool-1-thread-9
java.util.concurrent.ExecutionException: TaskException: Meet error in task.pool-1-thread-1
	at java.util.concurrent.FutureTask.report(FutureTask.java:122)
	at java.util.concurrent.FutureTask.get(FutureTask.java:188)
	at ExecutorServiceTest.main(ExecutorServiceTest.java:26)
Caused by: TaskException: Meet error in task.pool-1-thread-1
	at TaskWithResult.call(ExecutorServiceTest.java:54)
	at TaskWithResult.call(ExecutorServiceTest.java:37)
	at java.util.concurrent.FutureTask.run(FutureTask.java:262)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
	at java.lang.Thread.run(Thread.java:745)

Process finished with exit code 0