Future和FutureTask用法详细介绍

Future和FutureTask

在并发编程中，多线程的实现有继承Thread和Runnable，因为单继承的原因我们往往舍弃掉Thread而选择Runnable

同样的道理，无论是Thread还是Runnable在执行完任务之后无法获取执行结果，无法知道任务是否被完成。

因此Future和FutureTask成为了需要掌握的线程知识

Future

Future可以用于线程池，接受线程池submit返回的结果

public class FutureLearn {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService pool= Executors.newFixedThreadPool(5);
        Future<String> future=pool.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(3000);
                return "hello";
            }
        });
        System.out.println(future.get());

        pool.shutdown();
    }
}
复制代码

tips：

ExecutorService pool= Executors.newFixedThreadPool(5);
pool.submit();//是有返回值的，Future<T>类型
pool.execute();;//没有返回值
复制代码

FutureTask

FutureTask创建构造器里面传递callable函数

两种用法，一种在线程池直接exec或者submit都行

另一种写好之后放在new Thread()start

import java.util.concurrent.*;

public class MyFutureTask {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //FutureTask单独使用
        //FutureTask继承的是RunnableFuture，是和Runable是一个级别的，有run方法，但是直接使用run方法是跑在主线程上的
        //要new Thread(myFutureTask).start()才行 
        FutureTask<String> futureTask=new FutureTask<>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(2000);
                return "hello,world.I am FutureTask";
            }
        });
        new Thread(futureTask).start();//

        //FutureTask也可以配合线程池进行使用
        ExecutorService pool= Executors.newFixedThreadPool(2);
        FutureTask<String> futureTask1=new FutureTask<>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(1000);
                return "在线程池中使用FutureTask";
            }
        });
        pool.execute(futureTask1);
        

        System.out.println(futureTask1.get());

        System.out.println(futureTask.get());
        pool.shutdown();
    }
}
复制代码

Demo

code

package com.company;

import java.util.concurrent.*;

public class Call {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<String> callable=new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(6000);
                return "---------------------1";
            }
        };
        FutureTask<String> future=new FutureTask<>(callable);

        new Thread(future).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println(future.get());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        ExecutorService executorService=Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i=i+1) {
            int finalI = i;
            Future future1=executorService.submit(new Callable<String>() {
                @Override
                public String call() throws Exception {
                    Thread.sleep(finalI*1000);
                    return "==========================number is "+ finalI;
                }
            });
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(future1.get());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (ExecutionException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }

        for (int i = 0; i < 10; i++) {
            Thread.sleep(1000);
            System.out.println("main sleep "+i);
        }
        executorService.shutdown();

    }
}

复制代码

output

==========================number is 0
main sleep 0
==========================number is 1
==========================number is 2
main sleep 1
==========================number is 3
main sleep 2
==========================number is 4
main sleep 3
main sleep 4
---------------------1
main sleep 5
main sleep 6
main sleep 7
main sleep 8
main sleep 9

Process finished with exit code 0
复制代码