1. Future

Future接口中的get()会阻塞当前线程直到取得Callable的返回值

API文档

FutureTask 类是实现 Future ，实现 Runnable ，所以可以由 Executor 执行
FutureTask 可用于包装 Callable 或 Runnable 对象. 因为 FutureTask 实现 Runnable ，一个FutureTask可以提交到一个Executor执行

要想讲的清楚多线程，怎么能少得了我们的12306呢？今天，又是卖火车票的一天....

package com.ThreadPool;

import java.util.concurrent.*;

/**
 * @Author: Mr.Q
 * @Date: 2019-08-05 09:02
 * @Description:
 */
class CallableThread implements Callable<String> {
    private Integer tickets = 30;
    @Override
    public String call() throws Exception {
        for (int i = 0; i < tickets; i++) {
            if(tickets > 0) {
                System.out.println(Thread.currentThread().getName() +"还剩 "+tickets--+" 票...");
            }
        }
        return Thread.currentThread().getName() + "票卖完了！";
    }
}

public class FutureTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 线程池创建线程
        ThreadPoolExecutor threadPoolExecutor =
                new ThreadPoolExecutor(2,5,
                        60,TimeUnit.SECONDS,
                        new LinkedBlockingDeque<Runnable>());

        CallableThread callableThread = new CallableThread();
        // Future接口接收 Callable的返回值
        Future<String> future = null;
        for (int i = 0; i < 5; i++) {
        // submit()提交需要返回值的任务
             future = threadPoolExecutor.submit(callableThread);
        }
        //----------------- main - ---------------
        System.out.println(future.get());
        threadPoolExecutor.shutdown();
    }
}

get()会阻塞当前线程直到取得Callable的返回值

此时，在main()中调用get()，导致当前线程(主线程)阻塞，直到线程池中的子线程执行完毕后，在执行！

若此时我们把 get() 放在提交线程任务时调用

 Future<String> future = null;
        // 单线程模式 get()会阻塞当前线程，直到有返回值为止
       for (int i = 0; i < 5; i++) {
           Future<String> future0 = threadPoolExecutor.submit(callableThread);
           System.out.println(future0.get());
       }

那么此时阻塞当前提交任务的线程，也就是说，它没有提交完任务，其他的线程都不能执行，都得等着. 表面上看我们在最大池中创建了5个线程，可实际上执行任务的只有一个，其他的都在阻塞. 此时为 单线程模式

2. FutureTask

FutureTask : 可以保证在多线程场景下，任务只会被一个线程执行，其他线程不再执行此任务；
在多线程并发下可以保证任务(传入的Callable 或 Runnable)只执行一次

什么意思呢？ 就是我现在要给在火车站柜台买票的每一个人，买一张票，我就请他去候车室喝咖啡(虽然这是不可能的)

如果，我让一个乘务员来做这件事(把乘务员抽象的看作是一个线程)，他先得乘客卖票，然后再给乘客到候车室冲咖啡递上去，是不是很麻烦，效率很低?这要是到春运了，估计回家了，也就开学了....

那我再雇一个乘务员，一个负责卖票，另一个负责在候车室服务乘客，效率高，分工明确.

那么此时再看我们FutureTask的作用

可以保证在多线程场景下，任务只会被一个线程执行，其他线程不再执行此任务

相当于负责售票的乘务员A不管服务乘客,负责服务乘客的乘务员B不管卖票；

而开始的时候，这两件事情都由乘务员C来负责，两个任务都得执行.

这就是FutureTask的应用场景

最近也没怎么敲代码，但是头发却是哗哗的往下掉呀. 养生与学习并重，少熬夜，多运动. 然后，没事的时候，少喝点肥仔快乐水，多喝茶养生.

那我们就用FutureTask来实现一下泡茶的场景吧

现在，两个线程负责不同的任务，并且有一个线程在执行任务后，其他线程就不再执行任务

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;

/**
 * @Author: Mr.Q
 * @Date: 2019-08-07 09:17
 * @Description:
 */
// 线程1任务
class StepOne implements Callable<String> {
    private FutureTask<String> futureTask;

    public StepOne(FutureTask<String> futureTask) {
        this.futureTask = futureTask;
    }

    @Override
    public String call() throws Exception {
        System.out.println("T1：洗水壶.");
        TimeUnit.SECONDS.sleep(1);
        System.out.println("T1:烧开水..");
        TimeUnit.SECONDS.sleep(10);
        System.out.println("T1:等待茶叶...");
        // 线程1阻塞到此处一直等到线程2返回为止
        String str = futureTask.get();
        System.out.println("T1:拿到茶叶....");
        System.out.println("泡茶");
        return "上茶~~~";
    }
}

// 线程2任务
class StepTwo implements Callable<String> {

    @Override
    public String call() throws Exception {
        System.out.println("T2:洗茶壶*");
        TimeUnit.SECONDS.sleep(1);
        System.out.println("T2:洗茶杯**");
        TimeUnit.SECONDS.sleep(1);
        System.out.println("T2:拿茶叶***");
        TimeUnit.SECONDS.sleep(3);
        return "龙井";
    }
}

public class FutureThreadPoolDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask step2 = new FutureTask(new StepTwo());
        //将线程2的龙井茶传给线程1
        FutureTask step1 = new FutureTask(new StepOne(step2));
        new Thread(step1).start();
        new Thread(step2).start();
        // 主线程在step1,step2执行完之后再执行
        System.out.println(step1.get());
    }
}

执行过程：

好了，今天的养生课到这里就结束了，下课吧同学们...