線程池ExecutorService中submit和execute方法的區別

引言

     ExecutorService線程池執行線程時有submit 和execute 兩種方法，它們兩者之間有什麼區別了？可能平時我們只是運用，沒有深究其區別，在此我們可以看看它們的區別？

   1：executorService.execute()   

 1 public void execute(){
 2         ExecutorService executorService = Executors.newSingleThreadExecutor();
 3         executorService.execute(()->{
 4             try { 6                     Book book = new Book().setId("test" + (i + 1)).setName("平凡的世界").setAuthor("路遙").setContent("孫少安和田曉霞");
 7                     System.out.println("===book: " + JSONObject.toJSONString(book)); 9                 }
10             } catch (Exception e) {
11                 e.printStackTrace();
12             }
13         });
14         executorService.shutdown();
15     }

   無返回值，直接執行，因此不能阻塞線程，並且在執行異常時會拋出異常

 

 

 2：executorService.submit()方法

      有三種類型，返回future。    可以看ExecutorService接口的源碼，submit有三種調用方式，Callable回調、result結果、Runnable

public interface ExecutorService extends Executor {
    
    <T> Future<T> submit(Callable<T> task);
    
    <T> Future<T> submit(Runnable task, T result);
    
    Future<?> submit(Runnable task);
    
}

      2.1： 帶Callable回調函數的返回

 1 public void submit1() throws ExecutionException, InterruptedException {
 2         Callable<String> callable  = new Callable<String>() {
 3             @Override
 4             public String call() throws Exception {
 5                 return Thread.currentThread().getName()+"==== hello Callable";
 6             }
 7         };
 8         ExecutorService executorService = Executors.newSingleThreadExecutor();
 9         Future<String> future = executorService.submit(callable);
10         String s = executorService.submit(callable).get();
11         System.err.println(s);
12         System.out.println("======執行結果======"+future.get());
13         executorService.shutdown();
14     }

   返回結果：  

  

 

   2.2： 帶T result) 返回結果的

 1 public void submit2() throws ExecutionException, InterruptedException {
 2         ExecutorService executorService = Executors.newSingleThreadExecutor();
 3         Future<?> future = executorService.submit(() -> {
 4             try {
 5                     Book book = new Book().setId("test").setName("平凡的世界").setAuthor("路遙").setContent("孫少安和田曉霞");
 6                     System.out.println("===book: " + JSONObject.toJSONString(book));
 7             } catch (Exception e) {
 8                 e.printStackTrace();
 9             }
10         },"返回結果了！");
11         executorService.shutdown();
12         Object o = future.get();
13         System.out.println("=====執行結果======"+o);
14         System.out.println("=====isDone======"+future.isDone());
15         System.out.println("=====cancel======"+future.cancel(true));
16         System.out.println("=====isCancelled======"+future.isCancelled());
17     }

   返回結果：  

 

  2.3：(Runnable task);  //不帶返回結果

 1 public void submit3() throws ExecutionException, InterruptedException {
 2         ExecutorService executorService = Executors.newSingleThreadExecutor();
 3         Future<?> future = executorService.submit(() -> {
 4             try {
 5                     Book book = new Book().setId("test").setName("平凡的世界").setAuthor("路遙").setContent("孫少安和田曉霞");
 6                     System.out.println("===book: " + JSONObject.toJSONString(book));
 7             } catch (Exception e) {
 8                 e.printStackTrace();
 9             }
10         });
11         executorService.shutdown();
12         Object o = future.get();
13         System.out.println("=====執行結果======"+o);
14         System.out.println("=====isDone======"+future.isDone());
15         System.out.println("=====cancel======"+future.cancel(true));
16         System.out.println("=====isCancelled======"+future.isCancelled());
17     }

     返回結果：  

總結：

ExecutorService 的submit和execute的區別？
1: 接受的參數（任務類型）不一樣。 execute只能接受Runnable類型的任務,submit不管是Runnable還是Callable類型的任務都可以接受，但是Runnable返回值均爲void，所以使用Future的get()獲得的還是null
2：返回值。execute沒有返回值，submit有返回值，所以需要返回值的時候必須使用submit
3：異常的處理不同。
execute無返回值，直接執行，因此不能阻塞線程，並且在執行異常時會拋出異常
submit 有三種類型，返回future，可以阻塞獲取線程執行結果，在執行異常時會被異常處理喫掉，不會拋出異常