java Future类型

package com.zf.jdk.test.future;

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.Future;

public class WxMpMessageRouter {

    private Integer DEFAULT_POOL_SIZE=100;
    private ExecutorService executorService;

    public WxMpMessageRouter(){
        this.executorService = Executors.newFixedThreadPool(DEFAULT_POOL_SIZE);
    }
    
    public void testFuture(){
        List<FutureTask> list = FutureTask.getList();

        List<Future> futures = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            FutureTask futureTask = list.get(i);
            if (futureTask.getAsync()) {
                Future<?> submit = this.executorService.submit(new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            Thread.sleep(10000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(futureTask.getTaskName() + "正在异步执行");
                    }
                }));
                futures.add(submit);
            }else{
                System.out.println(futureTask.getTaskName()+"正在同步执行");
            }
        }
        if (futures.size() > 0) {
            this.executorService.submit(new Runnable() {
                @Override
                public void run() {
                    for (Future future : futures) {
                        try {
                            Object o = future.get();
                            System.out.println(o);
                            System.out.println("End session access: async=true,");
                        } catch (InterruptedException e) {
                            System.out.println("Error happened when wait task finish");
                            e.printStackTrace();
                        } catch (ExecutionException e) {
                            System.out.println("Error happened when wait task finish");
                            e.printStackTrace();
                        }
                    }
                }
            });
        }
    }

    /**
     * 异步任务
     */
    private static class FutureTask{
        /**
         * 任务名
         */
        private String taskName;
        /**
         * 是否异步
         */
        private Boolean async;

        public FutureTask(String taskName, Boolean async) {
            this.taskName = taskName;
            this.async = async;
        }

        public String getTaskName() {
            return taskName;
        }

        public void setTaskName(String taskName) {
            this.taskName = taskName;
        }

        public Boolean getAsync() {
            return async;
        }

        public void setAsync(Boolean async) {
            this.async = async;
        }
        
        public static List<FutureTask> getList(){
            List<FutureTask> list = new ArrayList<>();
            for (int i = 0; i < 10; i++) {
                FutureTask futureTask = new FutureTask(i + "", i < 2 ? true : false);
                list.add(futureTask);
            }
            return list;
        }
        
    }
}

　　总结:

使用 ExecutorService.submit()方法 可以异步执行 任务并立马返回 Future对象

在主线程中 使用 future.get() 会阻塞等待 异步任务执行完 

异步任务执行完, future.state 从0 变成 2