Java线程之FutureTask

忘是亡心i 2022-05-29 14:07 239阅读 0赞

## 简述 ##

FutureTask是Future接口的实现类，并提供了可取消的异步处理的功能，它包含了启动和取消（start and cancel）任务的方法，同时也包含了可以返回FutureTask状态（completed or cancelled）的方法。我们可以自定义一个Future任务，然后使用线程池执行器Java Thread Pool Executor 去异步执行任务。

## FutureTask ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA2NDcwMzU_size_16_color_FFFFFF_t_70]

从类图中可以看出，FutureTask实现了接口RunnableFuture，接口RunnableFuture又继承了Runnable和Future接口，所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的结果，因此FutureTask提供了两个构造方法：

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

## 使用事例 ##

1.使用Callable+Future获取执行结果

package com.lkf.mulithread;
    
    import java.util.concurrent.*;
    
    public class CallableFutureExample {
        public static void main(String[] args) {
            //创建线程池
            ExecutorService executor = Executors.newCachedThreadPool();
            //实例化任务
            MyTask task = new MyTask();
            //提交任务
            Future<Integer> result = executor.submit(task);
            //关闭线程池
            executor.shutdown();
    
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
    
            System.out.println("主线程在执行任务");
    
            try {
                System.out.println("MyTask的返回值："+result.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
    
            System.out.println("所有任务执行完毕");
        }
    
        static class MyTask implements Callable<Integer> {
            @Override
            public Integer call() throws Exception {
                System.out.println("子线程正在执行");
                Thread.sleep(5000);
                return 1000;
            }
        }
    }

2.使用Callable+FutureTask获取执行结果

package com.lkf.mulithread;
    
    import java.util.concurrent.*;
    
    public class FutureTaskExample {
        public static class MyCallable implements Callable<String> {
    
            private long waitTime;
    
            public MyCallable(int timeInMillis){
                this.waitTime=timeInMillis;
            }
            @Override
            public String call() throws Exception {
                Thread.sleep(waitTime);
                //返回当前线程的名字
                return Thread.currentThread().getName();
            }
    
        }
    
        public static void main(String[] args) {
            MyCallable callable1 = new MyCallable(1000);
            MyCallable callable2 = new MyCallable(2000);
    
            FutureTask<String> futureTask1 = new FutureTask<String>(callable1);
            FutureTask<String> futureTask2 = new FutureTask<String>(callable2);
    
            ExecutorService executor = Executors.newFixedThreadPool(2);
            executor.execute(futureTask1);
            executor.execute(futureTask2);
    
            while (true) {
                try {
                    if(futureTask1.isDone() && futureTask2.isDone()){
                        System.out.println("Done");
                        //shut down executor service
                        executor.shutdown();
                        return;
                    }
    
                    if(!futureTask1.isDone()){
                        //wait indefinitely for future task to complete
                        System.out.println("FutureTask1 output="+futureTask1.get());
                    }
    
                    System.out.println("Waiting for FutureTask2 to complete");
                    String s = futureTask2.get(200L, TimeUnit.MILLISECONDS);
                    if(s !=null){
                        System.out.println("FutureTask2 output="+s);
                    }
                } catch (InterruptedException | ExecutionException e) {
                    e.printStackTrace();
                }catch(TimeoutException e){
                    //do nothing
                }
            }
    
        }
    
    }

输出结果：

FutureTask1 output=pool-1-thread-1
    Waiting for FutureTask2 to complete
    Waiting for FutureTask2 to complete
    Waiting for FutureTask2 to complete
    Waiting for FutureTask2 to complete
    Waiting for FutureTask2 to complete
    FutureTask2 output=pool-1-thread-2
    Done

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA2NDcwMzU_size_16_color_FFFFFF_t_70]: /images/20220529/fc6d6ff7f9cc4607a599949a42e8f4cb.png