Callable、Future和FutureTask

時間  2019-11-12
標籤 callable future futuretask 简体版
原文   原文鏈接

建立線程的2種方式，一種是直接繼承Thread，另一種就是實現Runnable接口。 這2種方式都有一個缺陷就是：在執行完任務以後沒法獲取執行結果。
自從Java 1.5開始，就提供了Callable和Future，經過它們能夠在任務執行完畢以後獲得任務執行結果。
#CountDownLatch用法
先說一下java.lang.Runnable吧，它是一個接口，在它裏面只聲明瞭一個run()方法：java

public interface Runnable {
    public abstract void run();
}

因爲run()方法返回值爲void類型，因此在執行完任務以後沒法返回任何結果。
Callable位於java.util.concurrent包下，它也是一個接口，在它裏面也只聲明瞭一個方法，只不過這個方法叫作call()：ide

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包下，它是一個接口：oop

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只是一個接口，因此是沒法直接用來建立對象使用的，所以就有了下面的FutureTask。
    #FutureTask
public class FutureTask<V> implements RunnableFuture<V>{}
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接口的一個惟一實現類。 #使用示例code

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();
         
        //第2種方式
        //ExecutorService executor = Executors.newCachedThreadPool();
        //Task task = new Task();
        //FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
        //executor.submit(futureTask);
        //executor.shutdown();

        //第3種方式，注意這種方式和第2種方式效果是相似的，只不過一個使用的是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運行結果"+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
全部任務執行完畢對象

Thread、Runnable、Callable，其中Runnable實現的是void run()方法，Callable實現的是 V call()方法，而且能夠返回執行結果，其中Runnable能夠提交給Thread來包裝下，直接啓動一個線程來執行，而Callable則通常都是提交給ExecuteService來執行。
簡單來講，Executor就是Runnable和Callable的調度容器，Future就是對於具體的調度任務的執行結果進行查看，最爲關鍵的是Future能夠檢查對應的任務是否已經完成，也能夠阻塞在get方法上一直等待任務返回結果。Runnable和Callable的差異就是Runnable是沒有結果能夠返回的，就算是經過Future也看不到任務調度的結果的。繼承

/** 
 * 經過簡單的測試程序來試驗Runnable、Callable經過Executor來調度的時候與Future的關係 
 */  
package com.hadoop.thread;  
  
import java.util.concurrent.Callable;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.Future;  
  
public class RunnableAndCallable2Future {  
  
    public static void main(String[] args) {  
  
        // 建立一個執行任務的服務  
        ExecutorService executor = Executors.newFixedThreadPool(3);  
        try {  
            //1.Runnable經過Future返回結果爲空  
            //建立一個Runnable，來調度，等待任務執行完畢，取得返回結果  
            Future<?> runnable1 = executor.submit(new Runnable() {  
                @Override  
                public void run() {  
                    System.out.println("runnable1 running.");  
                }  
            });  
            System.out.println("Runnable1:" + runnable1.get());  
  
            // 2.Callable經過Future能返回結果  
            //提交併執行任務，任務啓動時返回了一個 Future對象，  
            // 若是想獲得任務執行的結果或者是異常可對這個Future對象進行操做  
            Future<String> future1 = executor.submit(new Callable<String>() {  
                @Override  
                public String call() throws Exception {  
                    // TODO Auto-generated method stub  
                    return "result=task1";  
                }  
            });  
            // 得到任務的結果，若是調用get方法，當前線程會等待任務執行完畢後才往下執行  
            System.out.println("task1: " + future1.get());  
  
            //3. 對Callable調用cancel能夠對對該任務進行中斷  
            //提交併執行任務，任務啓動時返回了一個 Future對象，  
            // 若是想獲得任務執行的結果或者是異常可對這個Future對象進行操做  
            Future<String> future2 = executor.submit(new Callable<String>() {  
                @Override  
                public String call() throws Exception {               
                    try {  
                        while (true) {  
                            System.out.println("task2 running.");  
                            Thread.sleep(50);  
                        }  
                    } catch (InterruptedException e) {  
                        System.out.println("Interrupted task2.");  
                    }  
                    return "task2=false";  
                }  
            });  
              
            // 等待5秒後，再中止第二個任務。由於第二個任務進行的是無限循環  
            Thread.sleep(10);  
            System.out.println("task2 cancel: " + future2.cancel(true));  
  
            // 4.用Callable時拋出異常則Future什麼也取不到了  
            // 獲取第三個任務的輸出，由於執行第三個任務會引發異常  
            // 因此下面的語句將引發異常的拋出  
            Future<String> future3 = executor.submit(new Callable<String>() {  
  
                @Override  
                public String call() throws Exception {  
                    throw new Exception("task3 throw exception!");  
                }  
  
            });  
            System.out.println("task3: " + future3.get());  
        } catch (Exception e) {  
            System.out.println(e.toString());  
        }  
        // 中止任務執行服務  
        executor.shutdownNow();  
    }  
}

執行結果以下：
runnable1 running.
Runnable1:null
task1: result=task1
task2 running.
task2 cancel: true
Interrupted task2.
java.util.concurrent.ExecutionException: java.lang.Exception:Bad flag value!
FutureTask則是一個RunnableFuture<V>，即實現了Runnbale又實現了Futrue<V>這兩個接口，另外它還能夠包裝Runnable和Callable<V>，因此通常來說是一個符合體了，它能夠經過Thread包裝來直接執行，也能夠提交給ExecuteService來執行，而且還能夠經過v get()返回執行結果，在線程體沒有執行完成的時候，主線程一直阻塞等待，執行完則直接返回結果.接口

public class FutureTaskTest {  
  
    /** 
     * @param args 
     */  
    public static void main(String[] args) {  
        Callable<String> task = new Callable<String>() {  
            public String call() {  
                System.out.println("Sleep start.");  
                try {  
                    Thread.sleep(1000 * 10);  
                } catch (InterruptedException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
                System.out.println("Sleep end.");  
                return "time=" + System.currentTimeMillis();  
            }  
        };  
          
        //直接使用Thread的方式執行  
        FutureTask<String> ft = new FutureTask<String>(task);  
        Thread t = new Thread(ft);  
        t.start();  
        try {  
            System.out.println("waiting execute result");  
            System.out.println("result = " + ft.get());  
        } catch (InterruptedException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        } catch (ExecutionException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
          
        //使用Executors來執行  
        System.out.println("=========");  
        FutureTask<String> ft2 = new FutureTask<String>(task);  
        Executors.newSingleThreadExecutor().submit(ft2);  
        try {  
            System.out.println("waiting execute result");  
            System.out.println("result = " + ft2.get());  
        } catch (InterruptedException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        } catch (ExecutionException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
          
    }  
}

執行結果以下：
waiting execute result
Sleep start.
Sleep end.
result = time=1370844662537

=========

waiting execute result Sleep start. Sleep end. result = time=1370844672542

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程