4.3.6 FutureTask核心思想

where-经典场景

查询多个系统数据后进行 汇总返回：

public class ThreadTest_Demo {

    static  ExecutorService executors = Executors.newScheduledThreadPool(2);

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        Callable<String> callable = new Callable<String>() {
            @Override
            public String call() throws Exception {
                //
                String str = "返回某个数据!";
                return str;
            }
        };
        Future<String> submit = executors.submit(callable);
//        System.out.println(submit.get());

        KaneFutureTask<String> futureTask = new KaneFutureTask<>(callable);
        new Thread(futureTask).start();
        System.out.println(futureTask.get());


    }
}


public class KaneFutureTask<T> implements Runnable {

    private Callable<T>  callable;

    T result;

    volatile  String state = "NEW";

    LinkedBlockingQueue<Thread> waiters = new LinkedBlockingQueue<>();

    public KaneFutureTask(Callable<T> callable) {
        this.callable = callable;
    }

    public T get(){ //阻塞，等待run方法执行完毕.
        if("END".equals(state)) {
            return result;
        }

        while (!"END".equals(state)){ //开始执行阻塞.
            //准备一个容器，通过这个容器来去存放线程。
            waiters.offer(Thread.currentThread());
            LockSupport.park();
        }

        return result;
    }

    @Override
    public void run() {
        try {
            result = callable.call();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            state = "END";
        }
        Thread waiter = waiters.poll();
        while (waiter!=null){
            LockSupport.unpark(waiter);
            waiter =waiters.poll();
        }
    }
}