在Java中如何使用Callable、Future進行并行編程

這篇文章將為大家詳細講解有關在Java中如何使用Callable、Future進行并行編程，小編覺得挺實用的，因此分享給大家做個參考，希望大家閱讀完這篇文章后可以有所收獲。

使用Callable、Future進行并行編程

在Java中進行并行編程最常用的方式是繼承Thread類或者實現Runnable接口。這兩種方式的缺點是在任務完成后無法直接獲取執行結果，必須通過共享變量或線程間通信，使用起來很不方便。

從Java1.5開始提供了Callable和Future兩個接口，通過使用它們可以在任務執行完畢后得到執行結果。

下面我們來學習下如何使用Callable、Future和FutureTask。

Callable接口

Callable接口位于java.util.concurrent包，這是一個泛型接口，里面只聲明了一個call()方法：

public interface Callable<T> {
  T call() throws Exception;
}

一般配合ExecutorService接口來使用它，在ExecutorService接口中聲明了幾個重載的submit方法：

<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);

第一個submit方法里面的參數類型就是Callable，另外兩個本文暫時不涉及。

Future和FutureTask

Future接口的實現類可以對Runnable或者Callable的任務執行取消、查詢、獲取結果的操作。

Future接口也位于java.util.concurrent包下：

public interface Future<T> {
  /**
  *取消任務
  *@param mayInterruptIfRunning
  *是否允許取消正在執行卻沒有執行完畢的任務，如果設置true，則表示可以取消正在執行過程中的任務
  *如果任務正在執行，則返回true
  *如果任務還沒有執行，則無論mayInterruptIfRunning為true還是false，返回true
  *如果任務已經完成，則無論mayInterruptIfRunning為true還是false，返回false
  */
  boolean cancel(boolean mayInterruptIfRunning);
  /**
  *任務是否被取消成功，如果在任務正常完成前被取消成功，則返回 true
  */
  boolean isCancelled();
  /**
  *任務是否完成
  */
  boolean isDone();
  /**
  *通過阻塞獲取執行結果
  */
  T get() throws InterruptedException, ExecutionException;
  /**
  *通過阻塞獲取執行結果。如果在指定的時間內沒有返回，則返回null
  */
  T get(long timeout, TimeUnit unit)
    throws InterruptedException, ExecutionException, TimeoutException;
}

總結下來Future提供了三種功能：

判斷任務是否完成
能夠中斷任務
能夠獲取任務執行的結果

JDK中為我們提供了一個Future接口的實現類FutureTask，它有如下兩個構造函數。

public FutureTask(Callable<T> callable) {
}
public FutureTask(Runnable runnable, T result) {
}

示例代碼

使用Callable、Future

import java.util.concurrent.*;
public class Test {
  public static void main(String[] args) {
    ExecutorService executorService = Executors.newCachedThreadPool();
    Task task = new Task();
    Future<Integer> future = executorService.submit(task);
    executorService.shutdown();
    
    System.out.println("主線程在執行任務...");
    try {
      Thread.sleep(2000);
    } catch(InterruptedException ex) {
      ex.printStackTrace();
    }
     
    try {
      System.out.println("task運行結果:"+future.get());
    } catch (InterruptedException ex) {
      ex.printStackTrace();
    } catch (ExecutionException ex) {
      ex.printStackTrace();
    } 
    System.out.println("所有任務執行完畢");
  }
}
class Task implements Callable<Integer>{
  @Override
  public Integer call() throws Exception {
    System.out.println("子線程在執行任務...");
    //模擬任務耗時
    Thread.sleep(5000);
    return 1000;
  }
}

執行結果：

子線程在執行任務...
主線程在執行任務...
task運行結果:1000
所有任務執行完畢

使用Callable、FutureTask

import java.util.concurrent.*;
public class Test {
  public static void main(String[] args) {
    ExecutorService executorService = Executors.newCachedThreadPool();
    Task task = new Task();
    FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
    executorService.submit(futureTask);
    executorService.shutdown();
    
    System.out.println("主線程在執行任務...");
    try {
      Thread.sleep(2000);
    } catch (InterruptedException ex) {
      ex.printStackTrace();
    }
     
    try {
      System.out.println("task運行結果:"+futureTask.get());
    } catch (InterruptedException ex) {
      ex.printStackTrace();
    } catch (ExecutionException ex) {
      ex.printStackTrace();
    }
     
    System.out.println("所有任務執行完畢");
  }
}
class Task implements Callable<Integer>{
  @Override
  public Integer call() throws Exception {
    System.out.println("子線程在執行任務...");
    //模擬任務耗時
    Thread.sleep(5000);
    return 1000;
  }
}

執行結果：

子線程在執行任務...
主線程在執行任務...
task運行結果:1000
所有任務執行完畢

關于“在Java中如何使用Callable、Future進行并行編程”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，使各位可以學到更多知識，如果覺得文章不錯，請把它分享出去讓更多的人看到。