Callable、Future和FutureTask怎么使用

本篇內(nèi)容主要講解“Callable、Future和FutureTask怎么使用”，感興趣的朋友不妨來(lái)看看。本文介紹的方法操作簡(jiǎn)單快捷，實(shí)用性強(qiáng)。下面就讓小編來(lái)帶大家學(xué)習(xí)“Callable、Future和FutureTask怎么使用”吧!

創(chuàng)建線程的2種方式，一種是直接繼承Thread，另外一種就是實(shí)現(xiàn)Runnable接口。 這2種方式都有一個(gè)缺陷就是：在執(zhí)行完任務(wù)之后無(wú)法獲取執(zhí)行結(jié)果。
自從Java 1.5開(kāi)始，就提供了Callable和Future，通過(guò)它們可以在任務(wù)執(zhí)行完畢之后得到任務(wù)執(zhí)行結(jié)果。
#CountDownLatch用法
先說(shuō)一下java.lang.Runnable吧，它是一個(gè)接口，在它里面只聲明了一個(gè)run()方法：

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

由于run()方法返回值為void類型，所以在執(zhí)行完任務(wù)之后無(wú)法返回任何結(jié)果。
Callable位于java.util.concurrent包下，它也是一個(gè)接口，在它里面也只聲明了一個(gè)方法，只不過(guò)這個(gè)方法叫做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;
}

可以看到，這是一個(gè)泛型接口，call()函數(shù)返回的類型就是傳遞進(jìn)來(lái)的V類型
那么怎么使用Callable呢？一般情況下是配合ExecutorService來(lái)使用的，在ExecutorService接口中聲明了若干個(gè)submit方法的重載版本

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

第一個(gè)submit方法里面的參數(shù)類型就是Callable。
　　暫時(shí)只需要知道Callable一般是和ExecutorService配合來(lái)使用的，具體的使用方法講在后面講述。
　　一般情況下我們使用第一個(gè)submit方法和第三個(gè)submit方法，第二個(gè)submit方法很少使用。
#Future
Future就是對(duì)于具體的Runnable或者Callable任務(wù)的執(zhí)行結(jié)果進(jìn)行取消、查詢是否完成、獲取結(jié)果。必要時(shí)可以通過(guò)get方法獲取執(zhí)行結(jié)果，該方法會(huì)阻塞直到任務(wù)返回結(jié)果。
Future類位于java.util.concurrent包下，它是一個(gè)接口：

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個(gè)方法，下面依次解釋每個(gè)方法的作用：

• cancel方法用來(lái)取消任務(wù)，如果取消任務(wù)成功則返回true，如果取消任務(wù)失敗則返回false。參數(shù)mayInterruptIfRunning表示是否允許取消正在執(zhí)行卻沒(méi)有執(zhí)行完畢的任務(wù)，如果設(shè)置true，則表示可以取消正在執(zhí)行過(guò)程中的任務(wù)。如果任務(wù)已經(jīng)完成，則無(wú)論mayInterruptIfRunning為true還是false，此方法肯定返回false，即如果取消已經(jīng)完成的任務(wù)會(huì)返回false；如果任務(wù)正在執(zhí)行，若mayInterruptIfRunning設(shè)置為true，則返回true，若mayInterruptIfRunning設(shè)置為false，則返回false；如果任務(wù)還沒(méi)有執(zhí)行，則無(wú)論mayInterruptIfRunning為true還是false，肯定返回true。

• isCancelled方法表示任務(wù)是否被取消成功，如果在任務(wù)正常完成前被取消成功，則返回 true。

• isDone方法表示任務(wù)是否已經(jīng)完成，若任務(wù)完成，則返回true；

• get()方法用來(lái)獲取執(zhí)行結(jié)果，這個(gè)方法會(huì)產(chǎn)生阻塞，會(huì)一直等到任務(wù)執(zhí)行完畢才返回；

• get(long timeout, TimeUnit unit)用來(lái)獲取執(zhí)行結(jié)果，如果在指定時(shí)間內(nèi)，還沒(méi)獲取到結(jié)果，就直接返回null。
  因?yàn)镕uture只是一個(gè)接口，所以是無(wú)法直接用來(lái)創(chuàng)建對(duì)象使用的，因此就有了下面的FutureTask。
  #FutureTask

public class FutureTask<V> implements RunnableFuture<V>{}
public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

可以看出RunnableFuture繼承了Runnable接口和Future接口，而FutureTask實(shí)現(xiàn)了RunnableFuture接口。所以它既可以作為Runnable被線程執(zhí)行，又可以作為Future得到Callable的返回值。
FutureTask提供了2個(gè)構(gòu)造器：

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

事實(shí)上，F(xiàn)utureTask是Future接口的一個(gè)唯一實(shí)現(xiàn)類。 #使用示例

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種方式效果是類似的，只不過(guò)一個(gè)使用的是ExecutorService，一個(gè)使用的是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("主線程在執(zhí)行任務(wù)");
        try {
            System.out.println("task運(yùn)行結(jié)果"+result.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("所有任務(wù)執(zhí)行完畢");
    }
}
class Task implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("子線程在進(jìn)行計(jì)算");
        Thread.sleep(3000);
        int sum = 0;
        for(int i=0;i<100;i++)
            sum += i;
        return sum;
    }
}

運(yùn)行結(jié)果：
子線程在進(jìn)行計(jì)算
主線程在執(zhí)行任務(wù)
task運(yùn)行結(jié)果4950
所有任務(wù)執(zhí)行完畢

Thread、Runnable、Callable，其中Runnable實(shí)現(xiàn)的是void run()方法，Callable實(shí)現(xiàn)的是 V call()方法，并且可以返回執(zhí)行結(jié)果，其中Runnable可以提交給Thread來(lái)包裝下，直接啟動(dòng)一個(gè)線程來(lái)執(zhí)行，而Callable則一般都是提交給ExecuteService來(lái)執(zhí)行。
簡(jiǎn)單來(lái)說(shuō)，Executor就是Runnable和Callable的調(diào)度容器，F(xiàn)uture就是對(duì)于具體的調(diào)度任務(wù)的執(zhí)行結(jié)果進(jìn)行查看，最為關(guān)鍵的是Future可以檢查對(duì)應(yīng)的任務(wù)是否已經(jīng)完成，也可以阻塞在get方法上一直等待任務(wù)返回結(jié)果。Runnable和Callable的差別就是Runnable是沒(méi)有結(jié)果可以返回的，就算是通過(guò)Future也看不到任務(wù)調(diào)度的結(jié)果的。

/** 
 * 通過(guò)簡(jiǎn)單的測(cè)試程序來(lái)試驗(yàn)Runnable、Callable通過(guò)Executor來(lái)調(diào)度的時(shí)候與Future的關(guān)系 
 */  
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) {  
  
        // 創(chuàng)建一個(gè)執(zhí)行任務(wù)的服務(wù)  
        ExecutorService executor = Executors.newFixedThreadPool(3);  
        try {  
            //1.Runnable通過(guò)Future返回結(jié)果為空  
            //創(chuàng)建一個(gè)Runnable，來(lái)調(diào)度，等待任務(wù)執(zhí)行完畢，取得返回結(jié)果  
            Future<?> runnable1 = executor.submit(new Runnable() {  
                @Override  
                public void run() {  
                    System.out.println("runnable1 running.");  
                }  
            });  
            System.out.println("Runnable1:" + runnable1.get());  
  
            // 2.Callable通過(guò)Future能返回結(jié)果  
            //提交并執(zhí)行任務(wù)，任務(wù)啟動(dòng)時(shí)返回了一個(gè) Future對(duì)象，  
            // 如果想得到任務(wù)執(zhí)行的結(jié)果或者是異?？蓪?duì)這個(gè)Future對(duì)象進(jìn)行操作  
            Future<String> future1 = executor.submit(new Callable<String>() {  
                @Override  
                public String call() throws Exception {  
                    // TODO Auto-generated method stub  
                    return "result=task1";  
                }  
            });  
            // 獲得任務(wù)的結(jié)果，如果調(diào)用get方法，當(dāng)前線程會(huì)等待任務(wù)執(zhí)行完畢后才往下執(zhí)行  
            System.out.println("task1: " + future1.get());  
  
            //3. 對(duì)Callable調(diào)用cancel可以對(duì)對(duì)該任務(wù)進(jìn)行中斷  
            //提交并執(zhí)行任務(wù)，任務(wù)啟動(dòng)時(shí)返回了一個(gè) Future對(duì)象，  
            // 如果想得到任務(wù)執(zhí)行的結(jié)果或者是異?？蓪?duì)這個(gè)Future對(duì)象進(jìn)行操作  
            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秒后，再停止第二個(gè)任務(wù)。因?yàn)榈诙€(gè)任務(wù)進(jìn)行的是無(wú)限循環(huán)  
            Thread.sleep(10);  
            System.out.println("task2 cancel: " + future2.cancel(true));  
  
            // 4.用Callable時(shí)拋出異常則Future什么也取不到了  
            // 獲取第三個(gè)任務(wù)的輸出，因?yàn)閳?zhí)行第三個(gè)任務(wù)會(huì)引起異常  
            // 所以下面的語(yǔ)句將引起異常的拋出  
            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());  
        }  
        // 停止任務(wù)執(zhí)行服務(wù)  
        executor.shutdownNow();  
    }  
}

執(zhí)行結(jié)果如下：
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則是一個(gè)RunnableFuture<V>，即實(shí)現(xiàn)了Runnbale又實(shí)現(xiàn)了Futrue<V>這兩個(gè)接口，另外它還可以包裝Runnable和Callable<V>，所以一般來(lái)講是一個(gè)符合體了，它可以通過(guò)Thread包裝來(lái)直接執(zhí)行，也可以提交給ExecuteService來(lái)執(zhí)行，并且還可以通過(guò)v get()返回執(zhí)行結(jié)果，在線程體沒(méi)有執(zhí)行完成的時(shí)候，主線程一直阻塞等待，執(zhí)行完則直接返回結(jié)果.

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的方式執(zhí)行  
        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來(lái)執(zhí)行  
        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();  
        }  
          
    }  
}

執(zhí)行結(jié)果如下：
waiting execute result
Sleep start.
Sleep end.
result = time=1370844662537

=========

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

到此，相信大家對(duì)“Callable、Future和FutureTask怎么使用”有了更深的了解，不妨來(lái)實(shí)際操作一番吧！這里是億速云網(wǎng)站，更多相關(guān)內(nèi)容可以進(jìn)入相關(guān)頻道進(jìn)行查詢，關(guān)注我們，繼續(xù)學(xué)習(xí)！