JAVA多线程高并发学习笔记(三)——Callable、Future和FutureTask

深藏阁楼爱情的钟 2022-05-27 06:46 173阅读 0赞

## 为什么要是用Callable和Future ##

### Runnable的局限性 ###

Executor采用Runnable作为基本的表达形式，虽然Runnable的run方法能够写入日志，写入文件，写入数据库等操作，但是它不能返回一个值，或者抛出一个受检查的异常，有些需要返回值的需求就不能满足了。

### 能够取消 ###

Executor中的任务有四个状态：创建，提交，开始和完成。如果说有些任务执行时间比较长，希望能够取消该任务，Executor中的任务在未开始前是可以取消的，如果已经开始了，只能通过中断的方式来取消。如果使用Callable和Future的结合，可以使用Future的canel方法取消任务，这样就方便多了。

## 一个例子： ##

import java.util.concurrent.*;
    
    public class Demo1 { 
    
        public static void main(String args[]) throws Exception { 
            ServiceTask task = new ServiceTask();
            ExecutorService executor = Executors.newCachedThreadPool();
            Future<Integer> result = executor.submit(task);
            executor.shutdown();
            System.out.println("正在执行任务");
            Thread.sleep(1000);
            System.out.println("task运行结果为:" + result.get());
        }
    }
    
    class ServiceTask implements Callable<Integer>{ 
        @Override
        public Integer call() throws Exception { 
            Thread.sleep(2000);
            int result = 0;
            // 假设一个很庞大的计算
            for(int i=1;i<100;i++){ 
                for (int j=0;j<i;j++){ 
                    result +=j;
                }
            }
            return result;
        }
    }

看一下执行结果：

![1620][]

这个例子就是一个非常简单的使用Callable和Futute的例子，ServiceTask类实现了Callable接口，并返回一个Integer类型的值。

Future<Integer> result = executor.submit(task);这行代码就是构造一个Future。使用其get()方法就能得到最后的运行值。

好了看完这一个简单的例子，那就来仔细了解一下它们。

## 了解Callable和Future ##

### Callable ###

来看一下callable的代码：

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

可以看出它是接口，提到接口就可以明白接口是灵活的,支持传入泛型参数。这个没什么，我们来重点介绍一下Future

## Future ##

首先来看关于它的介绍Future提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。计算完成后只能使用 get 方法来获取结果，如有必要，计算完成前可以阻塞此方法。取消则由 cancel 方法来执行。还提供了其他方法，以确定任务是正常完成还是被取消了。

来看一下Future的代码

public abstract interface Future<V> { 
        public abstract boolean cancel(boolean paramBoolean);
    
        public abstract boolean isCancelled();
    
        public abstract boolean isDone();
    
        public abstract V get() throws InterruptedException, ExecutionException;
    
        public abstract V get(long paramLong, TimeUnit paramTimeUnit)
                throws InterruptedException, ExecutionException, TimeoutException;
    }

提供了五个方法

public abstract boolean cancel(boolean paramBoolean)

试图取消任务的执行（注意是试图），因为存在一些任务已完成、已取消或者因为某些原因无法取消的因素，存在着取消失败的可能性。

当canel方法起作用时，有两个情况：

1.任务未开始，则该任务将永远不会运行；

2.任务处于执行状态，paramBoolean表示是否采用中断的方式中断线程。

public abstract boolean isCancelled()

如果任务正常取消的，则返回true。

public abstract boolean isDone();

如果任务已完成，则返回 true。 可能由于正常终止、异常或取消而完成，在所有这些情况中，此方法都将返回 true。

（注意如果调用isCanle方法，那么isDone将始终返回true）.

public abstract V get() throws InterruptedException, ExecutionException;

重点到了！这是Future获取计算结果的方式之一，使用get方法。（注意这里返回的是Callable中的泛型）

get方法取决于任务的状态（未开始，运行中，已完成），如果任务已经完成，那么get会立即返回或者抛出一个异常；

如果任务没有完成，那么get将阻塞知道任务完成。如果任务抛出了异常，那么get会将该异常封装成ExecutionException抛出。

public abstract V get(long paramLong, TimeUnit paramTimeUnit)
                throws InterruptedException, ExecutionException, TimeoutException;

如果需要在给定时间后获取计算结果，可以使用这个方法，如果超过给定时间之后没有得到计算结果，则抛出TimeoutException。（注意这里返回的是Callable中的泛型）

## 如何使用 ##

来看代码：

import java.util.concurrent.*;
    
    public class Demo1 { 
    
        public static void main(String args[]) throws Exception { 
            // 1.先实例化任务对象
            ServiceTask task = new ServiceTask();
            // 2.实例化Executor框架中的线程池
            ExecutorService executor = Executors.newCachedThreadPool();
            // 3.使用submit方法将任务提交（返回的是一个Future)
            Future<Integer> result = executor.submit(task);
            // 4.记得关闭线程池
            executor.shutdown();
            System.out.println("正在执行任务");
            Thread.sleep(1000);
            // 5.打印最后的结果
            System.out.println("task运行结果为:" + result.get());
        }
    }
    
    /** * Callable的实现类 */
    class ServiceTask implements Callable<Integer>{ 
        @Override
        public Integer call() throws Exception { 
            Thread.sleep(2000);
            int result = 0;
            // 假设一个很庞大的计算
            for(int i=1;i<100;i++){ 
                for (int j=0;j<i;j++){ 
                    result +=j;
                }
            }
            return result;
        }
    }

运行结果：

![1620 1][]

接下来我们来试一下定时取结果：

还是在原来的代码上修改：

import java.util.concurrent.*;
    
    public class Demo1 { 
    
        public static void main(String args[]) throws Exception { 
            // 1.先实例化任务对象
            ServiceTask task = new ServiceTask();
            // 2.实例化Executor框架中的线程池
            ExecutorService executor = Executors.newCachedThreadPool();
            // 3.使用submit方法将任务提交（返回的是一个Future)
            Future<Integer> result = executor.submit(task);
            // 4.记得关闭线程池
            executor.shutdown();
            System.out.println("正在执行任务");
            Thread.sleep(1000);
            // 5.设置定时一秒取结果
            System.out.println("task运行结果为:" + result.get(1,TimeUnit.MILLISECONDS));
        }
    }
    
    /** * Callable的实现类 */
    class ServiceTask implements Callable<Integer>{ 
        @Override
        public Integer call() throws Exception { 
            //这里睡眠2秒
            Thread.sleep(2000);
            int result = 0;
            // 假设一个很庞大的计算
            for(int i=1;i<100;i++){ 
                for (int j=0;j<i;j++){ 
                    result +=j;
                }
            }
            return result;
        }
    }

来提前猜想一下，首先设置了定时一秒之后取得结果，但是ServiceTask设置两秒的睡眠时间，理应取结果失败，看一下运行结果：

![1620 2][]

是的，如果在规定时间内无法取到结果，就会返回TimeoutException。

## 谈谈FutureTask ##

FutureTask是Future的实现类，它继承了RunnableFuture,RunnableFuture实际上继承了Runnable和Future接口。

来看一下使用如何FutureTask：

import java.util.concurrent.*;
    
    public class FutureCallDemo2 { 
    
        public static void main(String args[])throws  Exception{ 
            // 1.先实例化任务对象
            FutureTaskService task = new FutureTaskService();
            // 2.实例化Executor框架中的线程池
            ExecutorService excutor = Executors.newCachedThreadPool();
            // 3.直接new一个FutureTask
            FutureTask<Long> result = new FutureTask<Long>(task);
            // 4.提交任务
            excutor.submit(result);
            // 5.关闭线程池
            excutor.shutdown();
            System.out.println("主线程正在执行任务");
            System.out.println("task运行结果为:" + result.get());
        }
    }
    
    /** * 继承Callable接口 */
    class FutureTaskService implements Callable<Long> { 
    
        @Override
        public Long call() throws Exception { 
            Thread.sleep(3000);
            // 10的阶乘
            long sum = 1;
            for (int i = 1; i <= 10; i++) { 
                sum = sum * i;
            }
            return sum;
        }
    }

用法的话其实差不多。

##  ##

## 总结： ##

Future和Callable可以实现异构任务，但是有很多值得考虑的地方。

比如一个类使用了两个任务，一个负责渲染页面，一个负责下载图像。

伪代码如下：

//通过获取图像
    List<ImageData>ImageDataList = future.get();
    for(ImageData data:ImageDataList ){ 
      //渲染页面
      renderPage(data);    
    }

看似并行的执行任务，但是却存在着问题。如果说下载图像的速度远小于渲染页面的速度，那么最终的执行速度就和串行无异了。

所以只有当大量相互独立且同构的任务可以进行并发处理时，才能体现出将任务分到多个任务中带来的性能提升，考虑实际情况再选择使用会带来事半功倍的效果。

本文参考：

Java并发编程实战

[1620]: /images/20220527/ae500f90d48f4e54a27119bf7c0ae676.png
[1620 1]: /images/20220527/bf460a55aa4e4b00adf94216c178ba3a.png
[1620 2]: /images/20220527/2cb61b02c6f541919fd33e567fced041.png