一、在Android中的使用
1.gradle依赖
implementation "io.reactivex.rxjava2:rxjava:2.0.8"
implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'
implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.1.0'
implementation 'com.squareup.retrofit2:adapter-rxjava2:2.5.0'
注意，retrofit 2.9.0 已经内置了 java8 的 adapter，所以不需要 adapter-java8 的依赖了
另外，别忘了网络权限
2.定义接口
public interface GitHubService {
@GET("users/{user}/repos")
Observable> listRepos(@Path("user") String user);
@GET("users/{user}/repos")
CompletableFuture> listRepos2(@Path("user") String user);
}
上面的是 rxjava 的用法，下面是 CompletableFuture 的用法。我写在一起是为了比对
3.定义retrofit
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://api.github.com/")
.addConverterFactory(GsonConverterFactory.create())
.build();
GitHubService service = retrofit.create(GitHubService.class);
注意我们这里不需要添加 addCallAdapterFactory 了。因为 2.9.0 的源码里面内置了 CompletableFutureCallAdapterFactory。并且已经默认添加进去了
List defaultCallAdapterFactories(
@Nullable Executor callbackExecutor) {
DefaultCallAdapterFactory executorFactory = new DefaultCallAdapterFactory(callbackExecutor);
return hasJava8Types
? asList(CompletableFutureCallAdapterFactory.INSTANCE, executorFactory)
: singletonList(executorFactory);
}
具体代码在 Retrofit.Builder build 的时候 defaultCallAdapterFactories 里面有
4.网络请求
ExecutorService executorService = Executors.newFixedThreadPool(5);
CompletableFuture> future = service.listRepos2("octocat").handle(new BiFunction, Throwable, List>() {
@Override
public List apply(List repos, Throwable throwable) {
Log.e("handleAsync", Thread.currentThread().getName());//***************(1)
Log.e("handleAsync", repos.toString());
return repos;
}
});
try {
future.get(5, TimeUnit.SECONDS);//这里必须加 try catch***************(2)
future.thenApply(new Function, String>() {
@Override
public String apply(List repos) {
Log.e("thenApply2", Thread.currentThread().getName());//前面必须要有get，不然不会输出main
return null;
}
}).thenApply(new Function() {
@Override
public String apply(String repos) {
Log.e("thenApply2", Thread.currentThread().getName());//**********************(3)
return null;
}
});
} catch (Exception e) {
Log.e("handleAsync", e.toString());
}
接下来要解释几点
（1）1号注释那里输出啥？
listRepos2 返回 BodyCallAdapter。里面就是熟悉的 call.enqueue。如果没有特别指明线程池，那么肯定是 okhttp 里面自带的线程
所以就算在 handleAsync 里面指明线程池也没用，它只是改变了 apply 函数里面的线程。要想用自己设计的线程池必须要 okhttp 里面自己设定
PS:就算自己设定了线程池，输出的线程名字依然没有变是因为 NamedRunnable 改了名字
（2）为啥一定要get
主线程没有特定的线程池，所以只能用get让后面的方法在main上运行
（3）3号注释输出啥
和上一个操作符指定的线程一致。这一点和rxjava很像
二、原理解析
如果看过上一篇的话就会发现一个很奇怪的现象。在Java中 thenApply 会自动切换到主线程，而Android中和上一个操作符指明的线程一致。接下来就来分析一下为什么
（其实java中如果在 supplyAsync 里面添加了 Thread.sleep 也可以得到和 android 一样的结果，原因不明）
其实有了上面的使用基本也就知道了，CompletableFuture 是在主线程通过阻塞方法 get 来获取到子线程中的值的，根本不存在什么 Handler。严格意义上来讲里面没有“切换”的操作。更何况主线程也不可能通过 Executor 来包装。
那么接下来就大致讲解一下整个流程是如何串起来的。先来段示例代码
CompletableFuture.supplyAsync(new Supplier() {
@Override
public String get() {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
System.out.println("supplyAsync===" + Thread.currentThread().getName());
return "supplyAsync";
}
}).thenApply(new Function() {
@Override
public String apply(String t) {
System.out.println("apply===" + Thread.currentThread().getName());
return "apply";
}
});
在讲解之前先介绍一下数据结构吧
public class CompletableFuture implements Future, CompletionStage {
volatile Completion stack;
abstract static class Completion extends ForkJoinTask implements Runnable, AsynchronousCompletionTask {
volatile Completion next; // Treiber stack link
}
}
每个 CompletableFuture 内部有一个 stack(只是名字是 stack，其实还是个链表)。stack 内部有一个链表
supplyAsync
CompletableFuture d = new CompletableFuture();
e.execute(new AsyncSupply(d, f));
AsyncSupply 是个 Runnable，所以看 run 方法
public void run() {
CompletableFuture d; Supplier 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();
}
}
很简单，先计算结果，然后postComplete
final void postComplete() {
CompletableFuture f = this; Completion h;
while ((h = f.stack) != null ||
(f != this && (h = (f = this).stack) != null)) {
CompletableFuture d; Completion t;
if (f.casStack(h, t = h.next)) {// 从头遍历stack，并更新头元素
if (t != null) {
if (f != this) {
pushStack(h);// 如果f不是当前CompletableFuture，则将它的头结点压入到当前CompletableFuture的stack中，使树形结构变成链表结构，避免递归层次过深
continue;
}
h.next = null;// 如果是当前CompletableFuture, 解除头节点与栈的联系
}
f = (d = h.tryFire(NESTED)) == null ? this : d;//类似于钩子，执行对应 thenApply或者whenComplete的回调
}
}
}
supplyAsync 主要功能就是生成一个新的 CompletableFuture。等待 get 完成并且做点扫尾工作，然后 h.tryFire 下一个 CompletableFuture
thenApply
CompletableFuture d = newIncompleteFuture();
if (e != null || !d.uniApply(this, f, null)) {
UniApply c = new UniApply(e, d, this, f);
push(c);//把当前的UniApply 放到next中
c.tryFire(SYNC);//tryFire下一个
}
看到了吧，也是新生成 CompletableFuture。和 rxjava 类似。
static final class UniApply extends UniCompletion {
Function fn;
UniApply(Executor executor, CompletableFuture dep,
CompletableFuture src,
Function fn) {
super(executor, dep, src); this.fn = fn;
}
final CompletableFuture tryFire(int mode) {
CompletableFuture d; CompletableFuture a;
if ((d = dep) == null ||
!d.uniApply(a = src, fn, mode > 0 ? null : this))//这里面计算thenApply的function
return null;
dep = null; src = null; fn = null;
return d.postFire(a, mode);//最后绕来绕去还是会回到 postComplete
}
}
很明显，每一步都生成一个新的 CompletableFuture，然后通过 stack 串起来
PS: supplyAsync 最后提到的 扫尾工作 之所以没有展开来讲是因为我也没看懂dep的意思。stack对应的链式调用到时看明白了。如果想了解详细内容，可以参考如下两篇文章
CompletableFuture原理解析
CompletableFuture 原理浅析
2021.04.09
终于在okhttp里面找到了包装handler的方法了，现在就贴出来吧
public class MainThreadExecutor implements Executor {
private final Handler handler = new Handler(Looper.getMainLooper());
@Override
public void execute(@NonNull Runnable command) {
handler.post(command);
}
}
如果使用这个的话其实就和rxjava在代码结构上没啥区别，就是原理不一样。CompletableFuture 用到是链表，rxjava是用包一层新的obsevable