Java併發程式設計：Callable、Future和FutureTask

阿新 • • 發佈：2018-12-20

本篇說明的是Callable和Future，它倆很有意思的，一個產生結果，一個拿到結果。 Callable介面類似於Runnable，從名字就可以看出來了，但是Runnable不會返回結果，並且無法丟擲返回結果的異常，而Callable功能更強大一些，被執行緒執行後，可以返回值，這個返回值可以被Future拿到，也就是說，Future可以拿到非同步執行任務的返回值

建立執行緒的2種方式，一種是直接繼承Thread，另外一種就是實現Runnable介面。

　　這2種方式都有一個缺陷就是：在執行完任務之後無法獲取執行結果。

　　如果需要獲取執行結果，就必須通過共享變數或者使用執行緒通訊的方式來達到效果，這樣使用起來就比較麻煩。

　　而自從Java 1.5開始，就提供了Callable和Future，通過它們可以在任務執行完畢之後得到任務執行結果。

　　今天我們就來討論一下Callable、Future和FutureTask三個類的使用方法。以下是本文的目錄大綱：

　　一.Callable與Runnable

　　二.Future

　　三.FutureTask

一.Callable與Runnable

　　先說一下java.lang.Runnable吧，它是一個介面，在它裡面只聲明瞭一個run()方法：

public interface Runnable {

public abstract void run();

}

　　由於run()方法返回值為void型別，所以在執行完任務之後無法返回任何結果。

　　Callable位於java.util.concurrent包下，它也是一個介面，在它裡面也只聲明瞭一個方法，只不過這個方法叫做call()：

public interface Callable<V> {

/**

* Computes a result, or throws an exception if unable to do so.

*

* @return computed result

* @throws Exception if unable to compute a result

*/

V call() throws Exception;

}

　　可以看到，這是一個泛型介面，call()函式返回的型別就是傳遞進來的V型別。

　　那麼怎麼使用Callable呢？一般情況下是配合ExecutorService來使用的，在ExecutorService介面中聲明瞭若干個submit方法的過載版本：

<T> Future<T> submit(Callable<T> task);

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

Future<?> submit(Runnable task);

　　第一個submit方法裡面的引數型別就是Callable。

　　暫時只需要知道Callable一般是和ExecutorService配合來使用的，具體的使用方法講在後面講述。

　　一般情況下我們使用第一個submit方法和第三個submit方法，第二個submit方法很少使用。

二.Future

　　Future就是對於具體的Runnable或者Callable任務的執行結果進行取消、查詢是否完成、獲取結果。必要時可以通過get方法獲取執行結果，該方法會阻塞直到任務返回結果。

　　Future類位於java.util.concurrent包下，它是一個介面：

public interface Future<V> {

boolean cancel(boolean mayInterruptIfRunning);

boolean isCancelled();

boolean isDone();

V get() throws InterruptedException, ExecutionException;

V get(long timeout, TimeUnit unit)

throws InterruptedException, ExecutionException, TimeoutException;

}

　　在Future介面中聲明瞭5個方法，下面依次解釋每個方法的作用：

cancel方法用來取消任務，如果取消任務成功則返回true，如果取消任務失敗則返回false。引數mayInterruptIfRunning表示是否允許取消正在執行卻沒有執行完畢的任務，如果設定true，則表示可以取消正在執行過程中的任務。如果任務已經完成，則無論mayInterruptIfRunning為true還是false，此方法肯定返回false，即如果取消已經完成的任務會返回false；如果任務正在執行，若mayInterruptIfRunning設定為true，則返回true，若mayInterruptIfRunning設定為false，則返回false；如果任務還沒有執行，則無論mayInterruptIfRunning為true還是false，肯定返回true。
isCancelled方法表示任務是否被取消成功，如果在任務正常完成前被取消成功，則返回 true。
isDone方法表示任務是否已經完成，若任務完成，則返回true；
get()方法用來獲取執行結果，這個方法會產生阻塞，會一直等到任務執行完畢才返回；
get(long timeout, TimeUnit unit)用來獲取執行結果，如果在指定時間內，還沒獲取到結果，就直接返回null。

　　也就是說Future提供了三種功能：

　　1）判斷任務是否完成；

　　2）能夠中斷任務；

　　3）能夠獲取任務執行結果。

　　因為Future只是一個介面，所以是無法直接用來建立物件使用的，因此就有了下面的FutureTask。

三.FutureTask

　　我們先來看一下FutureTask的實現：

1	`public` `class` `FutureTask<V>` `implements` `RunnableFuture<V>`

　　FutureTask類實現了RunnableFuture介面，我們看一下RunnableFuture介面的實現：

public interface RunnableFuture<V> extends Runnable, Future<V> {

void run();

}

　　可以看出RunnableFuture繼承了Runnable介面和Future介面，而FutureTask實現了RunnableFuture介面。所以它既可以作為Runnable被執行緒執行，又可以作為Future得到Callable的返回值。

　　FutureTask提供了2個構造器：

public FutureTask(Callable<V> callable) {

}

public FutureTask(Runnable runnable, V result) {

}

　　事實上，FutureTask是Future介面的一個唯一實現類。

四.使用示例

　　1.使用Callable+Future獲取執行結果

public class Test {

public static void main(String[] args) {

ExecutorService executor = Executors.newCachedThreadPool();

Task task = new Task();

Future<Integer> result = executor.submit(task);

executor.shutdown();

try {

Thread.sleep(1000);

} catch (InterruptedException e1) {

e1.printStackTrace();

}

System.out.println("主執行緒在執行任務");

try {

System.out.println("task執行結果"+result.get());

} catch (InterruptedException e) {

e.printStackTrace();

} catch (ExecutionException e) {

e.printStackTrace();

}

System.out.println("所有任務執行完畢");

}

class Task implements Callable<Integer>{

@Override

public Integer call() throws Exception {

System.out.println("子執行緒在進行計算");

Thread.sleep(3000);

int sum = 0;

for(int i=0;i<100;i++)

sum += i;

return sum;

}

　　執行結果：

子執行緒在進行計算
主執行緒在執行任務
task執行結果4950
所有任務執行完畢

　　2.使用Callable+FutureTask獲取執行結果

public class Test {

public static void main(String[] args) {

//第一種方式

ExecutorService executor = Executors.newCachedThreadPool();

Task task = new Task();

FutureTask<Integer> futureTask = new FutureTask<Integer>(task);

executor.submit(futureTask);

executor.shutdown();

//第二種方式，注意這種方式和第一種方式效果是類似的，只不過一個使用的是ExecutorService，一個使用的是Thread

/*Task task = new Task();

FutureTask<Integer> futureTask = new FutureTask<Integer>(task);

Thread thread = new Thread(futureTask);

thread.start();*/

try {

Thread.sleep(1000);

} catch (InterruptedException e1) {

e1.printStackTrace();

}

System.out.println("主執行緒在執行任務");

try {

System.out.println("task執行結果"+futureTask.get());

} catch (InterruptedException e) {

e.printStackTrace();

} catch (ExecutionException e) {

e.printStackTrace();

}

System.out.println("所有任務執行完畢");

}

class Task implements Callable<Integer>{

@Override

public Integer call() throws Exception {

System.out.println("子執行緒在進行計算");

Thread.sleep(3000);

int sum = 0;

for(int i=0;i<100;i++)

sum += i;

return sum;

}

　　如果為了可取消性而使用 Future 但又不提供可用的結果，則可以宣告 Future<?> 形式型別、並返回 null 作為底層任務的結果。

原文連結：

參考連結：

Java併發程式設計：Callable、Future和FutureTask

本篇說明的是Callable和Future，它倆很有意思的，一個產生結果，一個拿到結果。 Callable介面類似於Runnable，從名字就可以看出來了，但是Runnable不會返回結果，並且無法丟擲返回結果的異常，而Callable功能更強大一些，被執行緒執

Java併發程式設計：Callable、Future和FutureTask 獲取返回值

在前面的文章中我們講述了建立執行緒的2種方式，一種是直接繼承Thread，另外一種就是實現Runnable介面。　　這2種方式都有一個缺陷就是：在執行完任務之後無法獲取執行結果。　　如果需要獲取執行結果，就必須通過共享變數或者使用執行緒通訊的方式來達到效果，這樣使用起來就比較麻煩。　

Java併發程式設計：Callable、Future和FutureTask原理解析

返回結果的任務Callable與Future Executor框架使用Runnable作為其基本的任務表示形式。Runnable是一種有很大侷限的抽象，它不能返回一個值或丟擲一個受檢查的異常。Runnable介面： public interface Ru

Java多線程編程：Callable、Future和FutureTask淺析

創建線程執行過程 data- body javase 接下來而後定義通過前面幾篇的學習，我們知道創建線程的方式有兩種，一種是實現Runnable接口，另一種是繼承Thread，但是這兩種方式都有個缺點，那就是在任務執行完成之後無法獲取返回結果，那如果我們想要獲取返

Java並發編程：Callable、Future和FutureTask

done 泛型 new row run new t com 取消底層在前面的文章中我們講述了創建線程的2種方式，一種是直接繼承Thread，另外一種就是實現Runnable接口。這2種方式都有一個缺陷就是：在執行完任務之後無法獲取執行結果。如果需要獲取執行結果，就必須通

Java併發程式設計：CountDownLatch、CyclicBarrier和 Semaphore

在java 1.5中，提供了一些非常有用的輔助類來幫助我們進行併發程式設計，比如CountDownLatch，CyclicBarrier和Semaphore，今天我們就來學習一下這三個輔助類的用法。以下是本文目錄大綱：一.CountDownLatch用法二.CyclicBarrier用法三.S

14-Java併發程式設計：CountDownLatch、CyclicBarrier和Semaphore

Java併發程式設計：CountDownLatch、CyclicBarrier和Semaphore 　　在java 1.5中，提供了一些非常有用的輔助類來幫助我們進行併發程式設計，比如CountDownLatch，CyclicBarrier和Semaphore，今天我們

Java併發程式設計：CountDownLatch、CyclicBarrier和Semaphore

一.CountDownLatch用法　　CountDownLatch類位於java.util.concurrent包下，利用它可以實現類似計數器的功能。比如有一個任務A，它要等待其他4個任務執行完畢之後才能執行，此時就可以利用CountDownLatch來實現

Java多執行緒20：多執行緒下的其他元件之CyclicBarrier、Callable、Future和FutureTask

CyclicBarrier 接著講多執行緒下的其他元件，第一個要講的就是CyclicBarrier。CyclicBarrier從字面理解是指迴圈屏障，它可以協同多個執行緒，讓多個執行緒在這個屏障前等待，直到所有執行緒都達到了這個屏障時，再一

Java多執行緒21：多執行緒下的其他元件之CyclicBarrier、Callable、Future和FutureTask

public static class CyclicBarrierThread extends Thread { private CyclicBarrier cb; private int sleepSecond; public CyclicBarrie

Java併發程式設計：執行緒安全和ThreadLocal

執行緒安全的概念：當多個執行緒訪問某一個類（物件或方法）時，這個類始終都能表現出正確的行為，那麼這個類（物件或方法）就是執行緒安全的。執行緒安全說的可能比較抽象，下面就以一個簡單的例子來看看什麼是執行緒安全問題。 public class MyThread

Java併發程式設計之CountDownLatch、CyclicBarrier和Semaphore

在java 1.5中，提供了一些非常有用的輔助類來幫助我們進行併發程式設計，比如CountDownLatch，CyclicBarrier和Semaphore，今天我們就來學習一下這三個輔助類的用法。 CountDownLatch CountDownLa

Java多執行緒（二）——Callable、Future和FutureTask

在上一章節我們介紹了Java實現多執行緒最常用的兩種方式，但是那兩種方式實現執行緒的時候並不能返回執行緒的執行結果。然而有些場景我們需要得到執行緒的執行結果，比如要計算每個部門的這個月的工資，然後進行總計（假設有n個部門，計算每個部門的工資需要花費m個小時，計算

java核心-多線程-線程類-Callable、Future和FutureTask

包裝示例概念 return time let thread .sh int 基本概念 <1>Callable,Callable和Runnable差不多，兩者都是為那些其實例可能被另一個線程執行的類而設計的，最主要的差別在於Runnable不會返回線程運算

Callable、Future和FutureTask簡介

線程池異步 rgs lex dem 抽象類及其 down ide 1. Runnable和Callable<v>、Future及其實現類FutureTask對比 Runnable和Callable<v>都是任務的抽象類，不同的是前者不會返回值，後

Callable、Future和FutureTask原理解析

返回結果的任務Callable與Future Executor框架使用Runnable作為其基本的任務表示形式。Runnable是一種有很大侷限的抽象，它不能返回一個值或丟擲一個受檢查的異常。Runnable介面： public interface Runnable {

多執行緒(九)Callable、Future和FutureTask

引言在前面的文章-多執行緒(一) 多執行緒介紹及基本使用中我們講述了建立執行緒的4種方式，其中一種是Callable、Future和FutureTask方式實現的。　　直接繼承Thread，或者實現Runnable介面都有一個缺陷就是：在執行完任務之

線程之Callable、Future 和FutureTask使用及源碼分析

images idt -c mage dex gem 傳遞 ont jdk源碼一、Callable 我們知道啟動線程有以下兩種方式（jdk源碼註釋中官方定義只有兩種啟動方式，callable不算線程啟動方式）原文鏈接：http://www.studyshare.cn/b

Java併發（十八）：阻塞佇列BlockingQueue BlockingQueue（阻塞佇列）詳解二叉堆(一)之圖文解析和 C語言的實現多執行緒程式設計：阻塞、併發佇列的使用總結 Java併發程式設計：阻塞佇列 java阻塞佇列 BlockingQueue（阻塞佇列）詳解

阻塞佇列（BlockingQueue）是一個支援兩個附加操作的佇列。這兩個附加的操作是：在佇列為空時，獲取元素的執行緒會等待佇列變為非空。當佇列滿時，儲存元素的執行緒會等待佇列可用。阻塞佇列常用於生產者和消費者的場景，生產者是往佇列裡新增元素的執行緒，消費者是從佇列裡拿元素的執行緒。阻塞佇列就是生產者

17-Java併發程式設計：執行緒間協作的兩種方式：wait、notify、notifyAll和Condition

Java併發程式設計：執行緒間協作的兩種方式：wait、notify、notifyAll和Condition 　　在前面我們將了很多關於同步的問題，然而在現實中，需要執行緒之間的協作。比如說最經典的生產者-消費者模型：當佇列滿時，生產者需要等待佇列有空間才能繼續往裡面放

Java併發程式設計：Callable、Future和FutureTask

一.Callable與Runnable

二.Future

三.FutureTask

四.使用示例

相關推薦