Java 高级应用-多线程-（四）FutureTask的介绍及使用

缺乏、安全感 2023-10-11 23:19 23阅读 0赞

**Java多线程之FutureTask的介绍及使用**

FutureTask属于java.util.concurrent 包；FutureTask表示可取消的异步计算。FutureTask类提供了一个Future的基本实现 ，具有启动和取消计算的方法，查询计算是否完整，并检索计算结果。结果只能在计算完成后才能检索; 如果计算尚未完成，则get方法将阻止。 一旦计算完成，则无法重新启动或取消计算（除非使用runAndReset()调用计算 ）

![在这里插入图片描述][1d8a92a1bfb040d4bb996641a5918167.png_pic_center]  
从上面的FutureTask类图中可以看出，FutureTask实现了RunnableFuture接口，RunnableFuture接口继承了Runnable接口和Future接口，所以FutureTask兼备Runnable和Future两种特性

![在这里插入图片描述][fd49bb13ea0e4012a6579f0be9836c8c.png_pic_center]

1、构造方法

public FutureTask(Callable callable) 创建一个 FutureTask ，它将在运行时执行给定的 Callable 。 参数： callable表示可调用任务 。  
public FutureTask(Runnable runnable,V result) 创建一个 FutureTask ，将在运行时执行给定的 Runnable ，并安排 get将在成功完成后返回给定的结果。 参数：runnable 表示可运行的任务 ；result 表示成功完成后返回的结果。  
2、常用的方法

public boolean isCancelled() 如果此任务在正常完成之前取消，则返回 true 。  
public boolean isDone() 返回true如果任务已完成。  
public V get() 等待计算完成，然后检索其结果。  
public V get(long timeout, TimeUnit unit)如果需要等待最多在给定的时间计算完成，然后检索其结果（如果可用）。  
public boolean cancel(boolean mayInterruptIfRunning)尝试取消执行此任务。  
protected void set(V v)将此未来的结果设置为给定值，除非此未来已被设置或已被取消。

案例  
通过示例进行多任务计算，通过get()方法可以异步获取执行结果。

1、创建一个计算任务类，实现Callable接口,重写call方法

package com.hz.thread.FutureTask;
    
    import java.util.concurrent.Callable;
    
    // 创建一个计算任务类，实现Callable接口,重写call方法
     
    public class ComputeTask implements Callable<Integer> {
        
    
        private String taskName;//任务名称
    
        //任务构造器
        public ComputeTask(String taskName) {
        
            this.taskName = taskName;
            System.out.println("创建【计算任务】开始，计算任务名称：" + taskName);
        }
    
        //计算任务的方法
        @Override
        public Integer call() throws Exception {
        
            Integer result = 0;
            for (int i = 1; i <=50; i++) {
        
                result = +i;
            }
            System.out.println("【计算任务】"+taskName +"执行完成。");
            return result;
        }
    }

2、创建一个测试类

package com.hz.thread.FutureTask;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.FutureTask;
    
    public class Demo {
        
        public static void main(String[] args) {
        
            //任务集合
            List<FutureTask<Integer>> futureTasks  = new ArrayList<>();
            //创建固定长度的线程池
            ExecutorService pool = Executors.newFixedThreadPool(5);
            for (int i = 1; i <= 10; i++) {
        
                //实例化FutureTask，传入计算任务类
                FutureTask<Integer> futureTask = new FutureTask<>(new ComputeTask(i + ""));
                //添加到任务集合中
                futureTasks.add(futureTask);
                //提交任务到线程池
                pool.submit(futureTask);
            }
            System.out.println("所有【计算任务】提交完毕，主线程开始执行");
    
            System.out.println("【主线程任务】开始============");
            //主线程睡眠5秒，模拟主线程做某些任务
            try {
        
                Thread.sleep(5000);
                System.out.println("【主线程任务】开始执行某些任务============");
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            System.out.println("【主线程任务】结束============");
    
            //用于打印任务执行结果
            Integer result = 0;
            for (FutureTask<Integer> task : futureTasks) {
        
                try {
        
                    //FutureTask的get()方法会自动阻塞，知道得到任务执行结果为止
                    result += task.get();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                } catch (ExecutionException e) {
        
                    e.printStackTrace();
                }
            }
            //关闭线程池
            pool.shutdown();
            System.out.println("多线程多任务执行结果：" + result);
    
        }
    
    }

3、输出结果如下：

创建【计算任务】开始，计算任务名称：1  
创建【计算任务】开始，计算任务名称：2  
创建【计算任务】开始，计算任务名称：3  
创建【计算任务】开始，计算任务名称：4  
创建【计算任务】开始，计算任务名称：5  
创建【计算任务】开始，计算任务名称：6  
创建【计算任务】开始，计算任务名称：7  
创建【计算任务】开始，计算任务名称：8  
创建【计算任务】开始，计算任务名称：9  
创建【计算任务】开始，计算任务名称：10  
所有【计算任务】提交完毕，主线程开始执行  
【主线程任务】开始============  
【计算任务】1执行完成。  
【计算任务】2执行完成。  
【计算任务】6执行完成。  
【计算任务】7执行完成。  
【计算任务】9执行完成。  
【计算任务】10执行完成。  
【计算任务】8执行完成。  
【计算任务】4执行完成。  
【计算任务】3执行完成。  
【计算任务】5执行完成。  
【主线程任务】开始执行某些任务============  
【主线程任务】结束============  
多线程多任务执行结果：500

4、结论  
![在这里插入图片描述][aac163fdb5e44d88932e4855b3409d42.png_pic_center]

通过FutureTask类的get()方法可用于异步获取执行结果，无论FutureTask调用多少次run()或者call()方法，它都能确保只执行一次Runable或Callable任务。

[1d8a92a1bfb040d4bb996641a5918167.png_pic_center]: https://img-blog.csdnimg.cn/1d8a92a1bfb040d4bb996641a5918167.png#pic_center
[fd49bb13ea0e4012a6579f0be9836c8c.png_pic_center]: https://img-blog.csdnimg.cn/fd49bb13ea0e4012a6579f0be9836c8c.png#pic_center
[aac163fdb5e44d88932e4855b3409d42.png_pic_center]: https://img-blog.csdnimg.cn/aac163fdb5e44d88932e4855b3409d42.png#pic_center