本文会结合Future描述下线程池的使用场景
最近因为换了工作，新工作需要更多的时间熟悉和上手，所以好久没有写文章了！
不过其实也一直有在看一些东西，比如Netty，spark源码（其实以前有看过，但是太囫囵吞枣忘得差不多了） ，然后想起我以前写过一个线程池相关的文章，但是对于线程池的使用只是一笔带过，所以今天想具体来写写
【java】线程池概念，如何使用线程池？：https://blog.csdn.net/lsr40/article/details/101428779
案例：
曾经做过这么一个案例，就是通过用户传入的参数，实时构建一份数据报表，这个功能肯定是异步的，相当于用户调用了一个create方法把参数传入进来，就直接返回了，不过后台会启动第一个线程池，来根据获得的参数实际查数据库，创建数据报表，保存到数据库，然后又启动了一个线程池（回调方法），这个线程池里面使用了Future的get方法来等待第一个线程池完毕，并且将create的记录修改为成功或者失败，并且记录相关原因！
话不多说！下面，我会用六个例子，来演示Future的用法（我上面说的案例，用的是第五种模型，只不过FutureTask我们又自己封装了一层，在里面做了时间的记录，日志的打印，或者一些前置的初始化操作等待）
代码示例：
package com.study.asyn;
import java.util.concurrent.*;
/**
* Created with IntelliJ IDEA
* Description:
* User: lsr
* Date: 2020/6/15
* Time: 18:46
*/
public class FutureTest {
public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
System.out.println("主线程开始工作：");
long startTime = System.currentTimeMillis();
ExecutorService executorService = Executors.newFixedThreadPool(1);
//newThreadDemo(executorService);
//futureGetDemo(executorService);
//futureGetAndTimeOutDemo(executorService);
//futureGetAndCallableDemo(executorService);
//callbackDemo(executorService);
futureTaskDemo(executorService);
long stopTime = System.currentTimeMillis();
System.out.println("主线程结束，耗时："+(stopTime - startTime)+"ms");
//关闭线程
executorService.shutdown();
}
/**
* 第一种，无所谓线程执行是否结束，不阻塞
* 打印结果：
* 主线程开始工作：
* 主线程结束，耗时：3ms
* 线程中的任务，开始运行！
* 正在执行！
* 线程中的任务，结束执行！
* @param executorService
* @throws ExecutionException
* @throws InterruptedException
*/
private static void newThreadDemo(ExecutorService executorService) throws ExecutionException, InterruptedException {
executorService.submit(new Runnable() {
public void run() {
System.out.println("线程中的任务，开始运行！");
doSomeThing();
System.out.println("线程中的任务，结束执行！");
}
});
}
/**
* 第二种，通过future的get方法，会阻塞等到执行完毕！
* 主线程开始工作：
* 线程中的任务，开始运行！
* 正在执行！
* 线程中的任务，结束执行！
* null
* 主线程结束，耗时：3005ms
* @param executorService
* @throws ExecutionException
* @throws InterruptedException
*/
private static void futureGetDemo(ExecutorService executorService) throws ExecutionException, InterruptedException {
Future<?> future = executorService.submit(new Runnable() {
public void run() {
System.out.println("线程中的任务，开始运行！");
doSomeThing();
System.out.println("线程中的任务，结束执行！");
}
});
Object o = future.get();
System.out.println(o);
}
/**
* 第三种，通过future的get方法，并且有超时时间，会阻塞等到执行完毕！
*
* 主线程开始工作：
* 线程中的任务，开始运行！
* 正在执行！
* 主线程结束，耗时：1007ms
* java.util.concurrent.TimeoutException
* at java.util.concurrent.FutureTask.get(FutureTask.java:205)
* at com.study.asyn.FutureTest.futureGetAndTimeOutDemo(FutureTest.java:99)
* at com.study.asyn.FutureTest.main(FutureTest.java:21)
* 线程中的任务，结束执行！
* @param executorService
* @throws ExecutionException
* @throws InterruptedException
*/
private static void futureGetAndTimeOutDemo(ExecutorService executorService) throws ExecutionException, InterruptedException {
Future<?> future = executorService.submit(new Runnable() {
public void run() {
System.out.println("线程中的任务，开始运行！");
doSomeThing();
System.out.println("线程中的任务，结束执行！");
}
});
Object o = null;
try {
o = future.get(1,TimeUnit.SECONDS);
System.out.println(o);
} catch (TimeoutException e) {
//true和false的区别大家可以看源码中的注释
//true就是中断当前执行的线程，false就是让线程执行完
future.cancel(false);
e.printStackTrace();
}
}
/**
* 第四种，通过future的get并且配合Callable方法，获得线程中return结果，会阻塞等到执行完毕！
* 主线程开始工作：
* 线程中的任务，开始运行！
* 正在执行！
* 线程中的任务，结束执行！
* 返回值~
* 主线程结束，耗时：3005ms
* @param executorService
* @throws ExecutionException
* @throws InterruptedException
*/
private static void futureGetAndCallableDemo(ExecutorService executorService) throws ExecutionException, InterruptedException {
Future<?> future = executorService.submit(new Callable<String>() {
public String call() throws Exception {
System.out.println("线程中的任务，开始运行！");
doSomeThing();
System.out.println("线程中的任务，结束执行！");
return "返回值~";
}
});
String returnValue = (String)future.get();
System.out.println(returnValue);
}
/**
* 第五种，想在获得future的get结果之后，再做一些处理，但是又不想阻塞主线程，通过回调，启动另一个线程来做这个事情
*
* 主线程开始工作：
* 线程中的任务，开始运行！
* 正在执行！
* 主线程结束，耗时：5ms
* 线程中的任务，结束执行！
* 返回值~
* 成功！
*
* @param executorService
* @throws ExecutionException
* @throws InterruptedException
*/
private static void callbackDemo(ExecutorService executorService) throws ExecutionException, InterruptedException {
ExecutorService fixExecutorService = Executors.newFixedThreadPool(1);
final Future<?> future = executorService.submit(new Callable<String>() {
public String call() throws Exception {
System.out.println("线程中的任务，开始运行！");
doSomeThing();
System.out.println("线程中的任务，结束执行！");
return "返回值~";
}
});
fixExecutorService.submit(new Runnable() {
public void run() {
String returnValue = null;
try {
returnValue = (String)future.get();
System.out.println(returnValue);
System.out.println("成功！");
} catch (Exception e) {
e.printStackTrace();
}
}
});
fixExecutorService.shutdown();
}
/**
* 第六种，之前线程都是使用submit提交任务，以此获得返回Future对象
* 但是使用升级版的FutureTask+线程池的execute方法，也能得到返回值
*
* 主线程开始工作：
* 线程中的任务，开始运行！
* 正在执行！
* 线程中的任务，结束执行！
* 返回值~
* 主线程结束，耗时：3005ms
*
* @param executorService
* @throws ExecutionException
* @throws InterruptedException
*/
private static void futureTaskDemo(ExecutorService executorService) throws ExecutionException, InterruptedException {
FutureTask<String> futureTask = new FutureTask<String>(new Callable<String>() {
public String call() throws Exception {
System.out.println("线程中的任务，开始运行！");
doSomeThing();
System.out.println("线程中的任务，结束执行！");
return "返回值~";
}
});
//execute方法虽然没有返回值，但是因为FutureTask实现类Future+Runnable，
// 所以也可以直接调用execute方法计算，再调用get获得返回结果
executorService.execute(futureTask);
String s = futureTask.get();
System.out.println(s);
}
private static void doSomeThing(){
try {
System.out.println("正在执行！");
Thread.sleep(3000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
结语：
好了，没有什么多余的东西要在这篇文章里说明了（每一种方法我都写好了注释，我也都跑过了，没什么问吐），大家要是有什么疑问，欢迎留言！
菜鸡一只，努力提升，学习中！！
刚开始工作的时候，觉得有些人做一些朝九晚五不过钱少的工作，看起来一点都不nice，实际自己工作了几年之后，认真想想那样的生活又何尝不痛快呢？大家都在享受人生，千人千面，有人因为工作有所成就而快乐，有人因为爱好有所精进而快乐，有人因为教书育人而快乐，又有人因为游戏涨段而快乐，其实只要收入能够维持自己物质上支出，那做什么又有什么区别呢？并没有那么多人想在工作中，实现自己的理想和抱负，完成个人价值的升华。
想起初中语文老师问我，以后的目标是什么？
读好书，做好人，生好下一代，培养之，那这辈子的使命不也算完成了？
有时候躺在草地上，呆呆的望向天空，轻柔的云朵，绵绵的细雨，徜徉在花海中，感受大自然高山流水，又何尝不是一种人生哲学呢？
下班了，溜了溜了！