Java的所有线程知识精华全在CompletableFuture了
目录
3、Executor，Executors，ExecutorService
今天在读项目代码的过程中发现了项目中有CompletableFuture的使用，虽然很早就知道这个类，也会使用但是从来没有探究代码的实现逻辑，今天凑着一个机会从里到外扒一扒这个类，希望能讲明白。
1、Thread,Runnable，Callable
1.1 线程的概念
先讲一讲线程，我想刚入门的同学都知道线程是什么，线程是为了提升cpu利用效率，防止阻塞的执行单位，举个例子，比如你正在做饭，发现家里没有酱油了，这时候你有两个选择，一个是停下手里的活，自己去打酱油，另外一个方式就是叫你儿子去打酱油，你儿子就是相当于一个新线程，帮你解决问题。打酱油这件事情就是一个任务。
1.2 线程的创建
所有的事情都可以从生活中发现蛛丝马迹，从上面的例子中我们可以看到，线程就是一个执行单位，可以具象理解为就是一个人，而要做的事情可以理解为一件任务，所以迁移到程序中我们可以理解线程。
Thread -> 人
Runnable->没有回复的任务
callable -> 有回复的任务
Runnable 和 callable 的不同就是有没有回复结果，比如在开发中发出命令不需要回复，当存储数据库的时候不关注结果，只是发出动作可以使用runnable，比如第一个例子的打酱油，是需要计算结果的，这个时候使用callable是合适的。
1.2.1 直接创建线程
通过继承Thread 创建线程，覆盖实现run方法，将任务代码写在run内，通过start 启动线程。
class MyThread extends Thread{ // 继承Thread类，作为线程的实现类
private String name ; // 表示线程的名称
public MyThread(String name){
this.name = name ; // 通过构造方法配置name属性
}
public void run(){ // 覆写run()方法，作为线程任务
for(int i=0;i<10;i++){
System.out.println(name + "运行，i = " + i) ;
}
}
};
public class ThreadDemo{
public static void main(String args[]){
MyThread mt1 = new MyThread("香菜A ") ; // 实例化对象
MyThread mt2 = new MyThread("香菜B ") ; // 实例化对象
mt1.start() ; // 开始执行任务吧
mt2.start() ; // 开始执行任务吧
}
}1.2.2 实现Runnable定义任务
Runnable 是一个接口，也就是一个规范，定义了任务的基本方法run，这个在有些也叫契约（垃圾概念）
这种方式是任务和线程进行分离，在启动线程的时候告诉他执行什么任务。只定义任务，随便来个线程都可以执行
class MyThread implements Runnable{ // 实现Runnable接口
public void run(){ // 覆写run()方法
while(true){
System.out.println(Thread.currentThread().getName() + "在运行。") ;
}
}
};
public class ThreadDemo{
public static void main(String args[]){
MyThread mt = new MyThread() ; // 实例化Runnable子类对象
Thread t = new Thread(mt,"线程"); // 实例化Thread对象
t.setDaemon(true) ; // 此线程在后台运行
t.start() ; // 启动线程
}
};1.2.3 通过callable 创建可以有返回值的任务
实现 Callable 接口， 相较于实现 Runnable 接口的方式，方法可以有返回值，并且可以抛出异常。
使用Callable 需要有 FutureTask的支持，再次使用上面打酱油的例子，你在让你儿子打酱油的时候说，等会打酱油回来之后可以直接放在桌子的左上角，你在做饭的过程中只要发现左上角有酱油就代表任务完成了。
FutureTask 可以理解为约定的一个地方，线程执行完之后就会把结果放在FutureTask的result容器中。具体的可以参照：《多线程系列二》不理解future怎么能有future？
public class TestCallable {
public static void main(String[] args) {
ThreadDemo td = new ThreadDemo();
//1.执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。
FutureTask<Integer> result = new FutureTask<>(td);
new Thread(result).start();
//2.接收线程运算后的结果
try {
Integer sum = result.get(); //FutureTask 可用于 闭锁 类似于CountDownLatch的作用，在所有的线程没有执行完成之后这里是不会执行的
System.out.println(sum);
System.out.println("------------------------------------");
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
class ThreadDemo implements Callable<Integer> {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i <= 100000; i++) {
sum += i;
}
return sum;
}
}小结：在理解多线程的时候主要映射到现实生活的需求中，Thread 就是一个人，需要做的事情就是任务，任务分为有回复的任务和无回复的任务，也就分出Runnable和Callable 了。
2、function，consumer
第二个话题其实是Java8 的新特性，在之前的工作经历中，发现还有很多人停留在Java6的语法上，不愿意学习也不愿意接受新的语法特性，究其原因是没理解，不能很好的掌握，这个我也写过一篇文章，里面有详细的说明。
一篇文章掌握lambda,function下41个类 我相信读完一定能一下掌握所有的function。
简单一句话概括，所有的function功能上和定义的函数一样，只不过定义了通用的结构，相当于通用的规则，只要填写代码就可以了，而这一组函数按不同的需求可以分为
Function 有返回值的函数，使用accept函数
Consumer 必须有参数的函数，使用apply函数
Supplier 有返回值的函数，使用get函数
3、Executor，Executors，ExecutorService
3.1 为什么要使用线程池
线程池这个大家都知道，是为了提高效率，可以类比生活，如果开个店，需要几个员工，正常的操作都是雇佣员工，而不是每天使用临时工，这样用完就解雇掉，对于店主来说招人的成本太高，还需要培训，我想正常的都不会这么做，线程池也是同样的道理，避免了创建和销毁线程的开销。
3.2Executor
java线程池中的一个顶级接口，其定义了一个接收Runnable对象的方法executor，其方法签名为executor(Runnable command),该方法接收一个Runable实例，它用来执行一个任务，任务即一个实现了Runnable接口的类，一般来说，在Executor中，可以使用Executor而不用显示地创建线程：
executor.execute(new RunnableTask()); // 异步执行3.3 ExecutorService
ExecutorService：是一个比Executor使用更广泛的子类接口，提供了生命周期管理的方法，返回 Future 对象，以及可跟踪一个或多个异步任务执行状况返回Future的方法；可以调用ExecutorService的shutdown（）方法来关闭 ExecutorService，调用该方法后，将导致ExecutorService停止接受任何新的任务且等待已经提交的任务执行完成(已经提交的任务会分两类：一类是已经在执行的，另一类是还没有开始执行的)，当所有已经提交的任务执行完毕后将会关闭ExecutorService。因此我们一般用该接口来实现和管理多线程。
3.4 Executors
Executors是个静态工厂类。它通过静态工厂方法返回ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 等类的对象。
newScheduledThreadPool 定时执行的线程池
newCachedThreadPool 缓存使用过的线程
newFixedThreadPool 固定数量的线程池
newWorkStealingPool 将大任务分解为小任务的线程池
可以看到提供了一些具体的线程池模型，可以根据自己的需求使用。
4、CompletableFuture
终于到我今天想说的了，上面的基本上都可以在我的博客中找到相关的专题，今天主要聊一下CompletableFuture。
4.1 CompletionStage
CompletionStage 的接口一般都返回新的CompletionStage，表示执行完一些逻辑后，生成新的CompletionStage，构成链式的阶段型的操作。
CompletionStage的接口方法可以从多种角度进行分类，可
以从函数的命名和函数进行分类
每个函数名可以拆分为三段，第一个单词表示触发时机，第二个表述stage之间的关系，最后一个表示执行的方式
从函数的参数可以看到主要是有返回值的function，消费型的Consumer以及runnable
4.2 CompletableFuture
先来个例子吧，可以运行下面的例子看下打酱油的全过程，并不影响你做菜。
public static void main(String[] args) throws InterruptedException {
CompletableFuture
//让儿子去打酱油
.supplyAsync(()-> {
try {
System.out.println("儿子跑步去打酱油");
TimeUnit.SECONDS.sleep(1);
System.out.println("酱油打好了");
} catch (InterruptedException e) {
e.printStackTrace();
}
return "酱油";
})
//告诉我一声
.thenAccept(oil->{
System.out.println("做菜用酱油:" + oil);
});
System.out.println("继续做菜");
Thread.currentThread().join();
}一个completetableFuture就代表了一个任务，看名字就知道和Future的关系。使用future需要等待isDone为true才能知道任务跑完了。或者就是用get方法调用的时候会出现阻塞。而使用completableFuture的使用就可以用then，when等等操作来防止以上的阻塞和轮询isDone的现象出现。
4.3 看下源码到底咋回事
4.3.1 线程池怎么回事
从上面的源码我们看到并没有我们之前知道的线程池相关的东西，也没使用线程池，到底是怎么做的呐？
打开源码瞧一瞧。
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
return asyncSupplyStage(asyncPool, supplier);
}Supplier 是一个有返回值的函数，在上面的例子中我们反悔了一个酱油的字符串。
在上面的return语句中我们看到使用了一个asyncPool，这是个什么东西？我们找下定义
/**
* Default executor -- ForkJoinPool.commonPool() unless it cannot
* support parallelism.
*/
private static final Executor asyncPool = useCommonPool ?
ForkJoinPool.commonPool() : new ThreadPerTaskExecutor();从上面的代码注释中我们看到，这是一个缺省的线程池，使用ForkJoinPool.commonPool()，这下我们明白了原来是使用了缺省的线程池。这个线程池默认创建的线程数是 CPU 的核数
4.3.2 怎么串行的?
CompletionStage的作用就是为了链式编程而存在的，所以可以猜测下CompletionStage 扮演了重要的作用，看下源码吧。
//1
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
return asyncSupplyStage(asyncPool, supplier);
}
//2
static <U> CompletableFuture<U> asyncSupplyStage(Executor e,
Supplier<U> f) {
if (f == null) throw new NullPointerException();
CompletableFuture<U> d = new CompletableFuture<U>();
e.execute(new AsyncSupply<U>(d, f));
return d;
}asyncSupplyStage()方法中，调用指定的线程池，并执行execute(new AsyncSupply(d,f))，这里d就是我们的“源任务”，接下来thenApply()要依赖着这个源任务进行后续逻辑操作，f是Supplier的函数式编程。
static final class AsyncSupply<T> extends ForkJoinTask<Void>
implements Runnable, AsynchronousCompletionTask {
CompletableFuture<T> dep; Supplier<T> fn;
AsyncSupply(CompletableFuture<T> dep, Supplier<T> fn) {
this.dep = dep; this.fn = fn;
}
public final Void getRawResult() { return null; }
public final void setRawResult(Void v) {}
public final boolean exec() { run(); return true; }
public void run() {
CompletableFuture<T> d; Supplier<T> f;
if ((d = dep) != null && (f = fn) != null) {
dep = null; fn = null;
if (d.result == null) {
try {
d.completeValue(f.get());
} catch (Throwable ex) {
d.completeThrowable(ex);
}
}
d.postComplete();
}
}
}在run()方法里。在run()方法里，先判断d.result == null，判断该任务是否已经完成，防止并发情况下其他线程完成此任务了。f.get()就是调用的Supplier的函数式编程。
主线程会在asyncSupplyStage()方法中返回d，就是我们的“依赖任务”，而这个任务此时还处在阻塞中。接下来main线程会继续执行CompletableFuture的thenAccept(Comsumer<? super T> action)方法，然后调用CompletableFuture的uniAcceptStage()方法。
CompletableFuture中有“源任务”和“依赖任务”，“源任务”的完成能够触发“依赖任务”的执行，这里的完成可以是返回正常结果或者是异常。
总结
CompletableFuture 是一个自带缺省线程池的，并且支持链式编程的，免去线程之间关系的类，在多线程编程中可以减少代码量，减少线程的调用，推荐
码字不易，求三连，求支持，为爱发电
相关文章
- SpringCloud Alibaba(五) - RocketMQ
- 内存马基础知识
- 【collection】1.java容器之HashMap&LinkedHashMap&Hashtable
- 面试官：你知道 Java 中的回调机制吗？我竟然答不来。。
- Java学习十一
- day11_多态&抽象类&接口
- Tomcat服务器部署＋Web项目搭建
- JAVA多线程有哪几种实现方式呢？
- 面试题系列：Java 夺命连环16问
- Dubbo 3.1.3、3.2.0-beta.2 正式发布
- 第2-4-10章 规则引擎Drools实战(3)-保险产品准入规则
- Android ViewPager2 + Fragment 联动
- Java学习十
- eclipse真的落后了嘛？这几点优势其他IDE比不上
- 10瓶毒药其中只有一瓶有毒至少需要几只老鼠可以找到有毒的那瓶
- maven的作用及配置教程
- day27-过滤器Filter02
- Java学习九
- Java利用fastjson解析复杂嵌套json字符串、json数组；json字符串转Java对象，json数组转list数组
- Class文件解析