Java多线程技术研究（四）-Callable，Future/FutureTask，及Future设计模式

超、凢脫俗 2022-06-13 00:22 134阅读 0赞

本篇博客Java多线程中另一块重要的内容：Callable，Future，FutureTask，及Future设计模式的模拟实现。  
考虑这样一种场景： 网上购物，提交订单后，在收货的这段时间里无需一直在家里等候，可以先干别的事情。类推到程序设计中时，当提交请求时，期望得到答复时，如果这个答复可能很慢。传统的做法一直等待直到收到应答，可能才会去做后续的事情。在Java中提供Callable和Future机制实现了异步调用，即主线程为得到某个答复，创建一个子线程等待该答复，然后主线程在这个过程中干其他事情，办完其它事情后再去获得答复。我们把这种设计称为Future设计模式。  
**1、Callable和Runnable**  
在Java多线程技术研究（一） 中，Callable和Runnable一样，都是实现多线程的一种方法，但是Runnable不会返回结果，并且无法抛出带返回结果的异常，而Callable功能更加强大一些，线程执行结束后可以返回结果。这个结果可以通过Future或FutureTask拿到该线程的返回值。  
Callable接口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;
    }

Runnable接口run()方法返回值为void型，显然不可获得其执行结果

public
    interface Runnable { 
        /** * When an object implementing interface <code>Runnable</code> is used * to create a thread, starting the thread causes the object's * <code>run</code> method to be called in that separately executing * thread. * <p> * The general contract of the method <code>run</code> is that it may * take any action whatsoever. * * @see java.lang.Thread#run() */
        public abstract void run();
    }

**2、Callable和Future获取线程执行结果**  
Future接口中定义有如下方法：  
**1）cancel()**

boolean cancel(boolean mayInterruptIfRunning);

取消任务的执行，mayInterruptRunning参数表示是否中断执行中的线程。  
**2）isCancelled()**

boolean isCancelled();

任务是否已取消，如果在正常完成前已取消返回true。  
**3）isDone()**

boolean isDone();

任务是否已完成，不管该任务是正常停止，异常导致，主动终止，均返回true。  
**4）get()**

V get() throws InterruptedException, ExecutionException;

获取异步执行的结果，如果任务没有执行结束，此方法会阻塞直到任务完成。  
**5） get(long timeout, TimeUnit unit)**

V get(long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException;

其中timeout为超时时间，unit为时间单位，如果在阻塞timeout时间，仍没有获得返回结果，get()方法会抛出TimeoutException异常。  
下面来看利用Callable和Future获取线程执行结果

package com.wygu.thread.study;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Future;
    import java.util.concurrent.FutureTask;
    
    public class MultiThreadCallable {
        public static void main(String []argv){
            TaskCallable tCallable = new TaskCallable();
            ExecutorService executorService = Executors.newSingleThreadExecutor(); 
            //将任务提交到线程池中  
            Future<Integer> future =executorService.submit(tCallable); 
            //主线程可以进行其他事情   
             try {
                Integer result = future.get();
                System.out.println("子线程返回结果为："+result);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    
    }
    
    class TaskCallable implements Callable<Integer>{
        @Override
        public Integer call(){
            int num=10;
            try {
                Thread.sleep(3000);
                 num+=10;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
           return num;
        }
    }

子线程返回结果为：20

**3、Callable和FutureTask**  
首先看一下类FutureTask的实现：

public class FutureTask<V> implements RunnableFuture<V>

FutureTask实现了接口RunnableFuture，而对于RunnableFuture的实现：

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

RunnableFuture不仅实现了Future中的方法，还实现了Runnable中run方法。  
因而FutureTask不仅可以直接提交给Executor执行，还可以调用线程直接执行FutureTask中实现的run()方法.  
通过FutureTask的下述两种构造方法，利用FutureTask可以获得Runnable的中执行结果。

public FutureTask(Callable<V> callable) {
            if (callable == null)
                throw new NullPointerException();
            this.callable = callable;
            this.state = NEW;       // ensure visibility of callable
        }
        public FutureTask(Runnable runnable, V result) {
            this.callable = Executors.callable(runnable, result);
            this.state = NEW;       // ensure visibility of callable
        }

下面来看利用Callable和FutureTask获取线程执行结果

public class MultiThreadCallable { 
        public static void main(String []argv){
            TaskCallable tCallable = new TaskCallable();
             FutureTask<Integer> futureTask = new FutureTask<Integer>(tCallable);
             new Thread(futureTask,"带返回值的线程").start();
             //主线程可以进行其他事情 
             try {
                Integer result = futureTask.get();
                System.out.println("子线程返回结果为："+result);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    
    }
    
    class TaskCallable implements Callable<Integer>{ 
        @Override
        public Integer call(){
            int num=10;
            try {
                Thread.sleep(3000);
                 num+=10;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
           return num;
        }
    }

程序执行结果：  
子线程返回结果为：20

**4、Future设计模式的模拟实现**  
在前面的场景中：网上挑好物品后，提交表单会获得一个订单，然后就可以等待收货，在收货的这段时间里无需一直在家里等候，可以先干别的事情。  
![这里写图片描述][SouthEast]  
图片来源于：[http://blog.csdn.net/ghuil/article/details/41048017][http_blog.csdn.net_ghuil_article_details_41048017]  
**在传统多线程模式**，采用的是同步调用方式，Client发出call请求后，会一直等待服务端给予真实的应答数据，只有当Client等待到应答后，才能进行其它事情。**而在Future设计模式调用中**，Client发出call请求后，Server端会立即给予Client端一个应答，此时的应答数据可以说是一个假数据（不是真实的结果），Client端收到Server端的应答后，就去处理其它事情了，而Server端内部可以慢慢的生产数据，完成后把放置在对象中，等待Client端获取。  
下面给出Future模式的程序实现  
**1）FutureClient的实现**  
FutureClient主要功能包括：获得假数据FutureData，获得真实数据RealData

package com.wygu.futurePattern;
    
    public class FutureClient<T> {
        private T requestData = null;
    
        public FutureClient(T requestdata){
            this.requestData = requestdata;
        }
        //创建方法，获得真实的数据
        public FutureData<T> callForBack(){
            final FutureData<T> fData = new FutureData<T>();
    
            new Thread(new Runnable() {
    
                @Override
                public void run() {
                    RealData<T> realData = new RealData<T>(requestData);
                    fData.setRealData(realData);
    
                }
            }).start();
            return fData;
        }
    }

**2）Data的实现**  
接口Data中，定义一个获得数据的方法getResult()，在FutureData，RealData均重新实现该接口。其中FutureData可以说是对RealData的代理，它会封装RealData的getResult()方法。  
**Data接口定义**

package com.wygu.futurePattern;
    
    public interface Data<T> {
        public T getResult()  throws InterruptedException;
    }

**FutureData的实现**

package com.wygu.futurePattern;
    
    
    public class FutureData<T> implements Data<T>{ 
        private RealData<T> realData = null;
        private volatile boolean isReady = false;
    
        public synchronized void setRealData(RealData<T> realData) {
            //判断真实数据是否已完成
            if(isReady){
                return;
            }
            this.realData = realData;
            //数据已生产好
            this.isReady = true;
            //唤醒等待的线程
            notifyAll();
    
        }
    
    
        @Override
        public synchronized T getResult() throws InterruptedException {
            if(!isReady){
                wait();//阻塞调用该方法的线程，产生真实的数据
            }
            return realData.getResult();
        }
    
    }

**RealData的实现**

package com.wygu.futurePattern;
    
    @SuppressWarnings("rawtypes")
    public class RealData<T> implements Data{ 
        private T realData = null;
    
        public RealData(T realData) {
            //使用sleep模拟生产真实数据很慢
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.realData = realData;
        }
    
        @Override
        public T  getResult() throws InterruptedException{  
            //获取生产的真实数据
            return realData;
        }
    
    }

**3）测试运行**

package com.wygu.futurePattern;
    
    public class Main {
    
        public static void main(String[] args) {
            long start = System.currentTimeMillis();
            FutureClient<String> futureClient = new FutureClient<String>("Hi,Future Pattern");
            //主线程创建Client实例，去请求真实数据
            FutureData<String> futureData = futureClient.callForBack();
            //让主线程沉睡一段时间，在去获得真实数据
            try {
                Thread.sleep(9000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                System.out.println("Client 获取真实数据："+futureData.getResult()+",共耗时："+(System.currentTimeMillis()-start)+"毫秒");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
        }
    
    }

运行结果为：Client 获取真实数据：Hi,Future Pattern,共耗时：9997毫秒  
修改主线程做其他工作时间（沉睡时间）为Thread.sleep(11000)，运行结果为：Client 获取真实数据：Hi,Future Pattern,共耗时：10994毫秒。假设主线程的处理其它事物的时间为t1，Server端产生真实数据的时间为t2，则主线程运行结束的时间为max（t1,t2）.

[SouthEast]: /images/20220613/d8a0afc0bcc54269a77cd1ccf80bb0ee.png
[http_blog.csdn.net_ghuil_article_details_41048017]: http://blog.csdn.net/ghuil/article/details/41048017