本文主要基于 Hystrix 1.5.X 版本

1. 概述

本文主要分享 Hystrix 执行命令的结果缓存。

建议：对 RxJava 已经有一定的了解的基础上阅读本文。

Hystrix 执行命令整体流程如下图：

红圈：在《高并发神器Hystrix源码阅读 —— 执行命令方式》有详细解析。
紫圈：在 #toObservable() 方法里，如果请求结果缓存这个特性被启用，并且缓存命中，则缓存的回应会立即通过一个 Observable 对象的形式返回；如果缓存未命中，则返回【订阅了执行命令的 Observable】的 ReplySubject 对象缓存执行结果。
- ReplySubject 能够重放执行结果，从而实现缓存的功效。本文不对 ReplySubject 做太多拓展，感兴趣的同学可以阅读《ReactiveX/RxJava文档中文版 —— Subject》。

在官方提供的示例中，我们使用 CommandUsingRequestCache 进行调试。

2. 好处

点击《【翻译】Hystrix文档-实现原理》「请求缓存」，查看对请求缓存的好处分享，写的真的很赞。

3. Observable#defer(…)

本小节为拓展内容，源码解析 RxJava ( 非 Hystrix ) 的 Observable#defer(...) 的方法实现。考虑到 Hystrix 大量使用，为了更好的理解，可以读一下RxJava的源码实现。

4. AbstractCommand#toObservavle(…)

AbstractCommand#toObservavle(...) 方法，代码如下：

public Observable<R> toObservable() {
     final AbstractCommand<R> _cmd = this;

     //doOnCompleted handler already did all of the SUCCESS work
     //doOnError handler already did all of the FAILURE/TIMEOUT/REJECTION/BAD_REQUEST work
     final Action0 terminateCommandCleanup = new Action0() {} // ... 省略
 
     //mark the command as CANCELLED and store the latency (in addition to standard cleanup)
      final Action0 unsubscribeCommandCleanup = new Action0() {} // ... 省略 
     final Func0<Observable<R>> applyHystrixSemantics = new Func0<Observable<R>>() {
         @Override
         public Observable<R> call() {
             if (commandState.get().equals(CommandState.UNSUBSCRIBED)) {
                 return Observable.never();
             }
             return applyHystrixSemantics(_cmd);
         }
     };
 
     final Func1<R, R> wrapWithAllOnNextHooks = new Func1<R, R>() {} // ... 省略 
 
     final Action0 fireOnCompletedHook = new Action0() {} // ... 省略 
 
     return Observable.defer(new Func0<Observable<R>>() {
         @Override
         public Observable<R> call() {
             /* this is a stateful object so can only be used once */
             if (!commandState.compareAndSet(CommandState.NOT_STARTED, CommandState.OBSERVABLE_CHAIN_CREATED)) {
                 IllegalStateException ex = new IllegalStateException("This instance can only be executed once. Please instantiate a new instance.");
                 //TODO make a new error type for this
                throw new HystrixRuntimeException(FailureType.BAD_REQUEST_EXCEPTION, _cmd.getClass(), getLogMessagePrefix() + " command executed multiple times - this is not permitted.", ex, null);
             }
 
             // 命令开始时间戳
             commandStartTimestamp = System.currentTimeMillis();
 
             // TODO【2001】【打印日志】
             if (properties.requestLogEnabled().get()) {
                 // log this command execution regardless of what happened
                 if (currentRequestLog != null) {
                     currentRequestLog.addExecutedCommand(_cmd);
                 }
             }
 
             // 缓存开关、缓存KEY
             final boolean requestCacheEnabled = isRequestCachingEnabled();
             final String cacheKey = getCacheKey();
 
             // 优先从缓存中获取
             /* try from cache first */
             if (requestCacheEnabled) {
                 HystrixCommandResponseFromCache<R> fromCache = (HystrixCommandResponseFromCache<R>) requestCache.get(cacheKey);
                 if (fromCache != null) {
                     isResponseFromCache = true; // 标记 从缓存中结果
                    return handleRequestCacheHitAndEmitValues(fromCache, _cmd);
                 }
             }
 
             // 获得 执行命令Observable
             Observable<R> hystrixObservable =
                     Observable.defer(applyHystrixSemantics)
                             .map(wrapWithAllOnNextHooks);
 
             // 获得 缓存Observable
             Observable<R> afterCache;
             // put in cache
             if (requestCacheEnabled && cacheKey != null) {
                 // wrap it for caching
                 HystrixCachedObservable<R> toCache = HystrixCachedObservable.from(hystrixObservable, _cmd);
                 // 并发若不存在
                 HystrixCommandResponseFromCache<R> fromCache = (HystrixCommandResponseFromCache<R>) requestCache.putIfAbsent(cacheKey, toCache);
                 if (fromCache != null) { // 添加失败
                     // another thread beat us so we'll use the cached value instead
                     toCache.unsubscribe();
                     isResponseFromCache = true; // 标记 从缓存中结果
                    return handleRequestCacheHitAndEmitValues(fromCache, _cmd);
                } else { // 添加成功
                    // we just created an ObservableCommand so we cast and return it
                    afterCache = toCache.toObservable();
                }
            } else {
                afterCache = hystrixObservable;
            }

            //
            return afterCache
                    .doOnTerminate(terminateCommandCleanup)     // perform cleanup once (either on normal terminal state (this line), or unsubscribe (next line))
                     .doOnUnsubscribe(unsubscribeCommandCleanup) // perform cleanup once
                     .doOnCompleted(fireOnCompletedHook);
         }
     });
 }

第 2 行：_cmd 指向当前命令对象，用于下面实现 FuncX ，ActionX 内部类使用。
第 11 至 19 行：当缓存特性未开启，或者缓存未命中时，使用 applyHystrixSemantics 传入 Observable#defer(...) 方法，声明执行命令的 Observable。
第 25 行：声明缓存 Observable 。Hystrix 执行命令的 Observable 声明关系如下：
第 29 至 33 行：一条命令只能执行一次。
第 36 行：记录命令开始时间戳。
第 38 至 44 行：TODO【2001】【打印日志】
第 47 至 48 行：缓存存开关、KEY 。
第 52 至 58 行：如果请求结果缓存这个特性被启用，并且缓存命中，则缓存的回应会立即通过一个 Observable 对象的形式返回。
- 第 53 行：requestCache 缓存，内容太多在后续博客详细解析。
- 第 53 行：内容太多在后续博客详细解析。
- 第 56 行：#handleRequestCacheHitAndEmitValues(...) 方法，在第 78 行详细解析。
第 61 至 63 行：获取执行命令的 Observable 。内容太多在后续博客详细解析。
第 68 至 81 行：当缓存特性开启，并且缓存未命中时，创建【订阅了执行命令的 Observable】的 HystrixCommandResponseFromCache 。
- 第 69 至 72 行：创建 HystrixCommandResponseFromCache ，并添加到 requestCache 。哟，HystrixRequestCache#putIfAbsent(...) 方法，多个线程添加时，只有一个线程添加成功。
- 第 73 至 77 行：添加失败的线程( 们 )：
  - 第 75 行：调用 HystrixCommandResponseFromCache#unsubscribe() 方法，取消 HystrixCommandResponseFromCache 的订阅。这一步很关键，因为我们不希望缓存不存在时，多个线程去执行命令，最好有且只有一个线程执行命令。内容太多在后续博客细解析。
  - 第 77 行：内容太多在后续博客详细解析。
    - 第 80 行：调用 HystrixCommandResponseFromCachetoObservable() 方法，获得缓存 Observable 。
第 82 至 84 行：当缓存特性未开启，使用执行命令 Observable 。
第 87 至 91 行：在返回的 Observable 上，订阅一些清理的处理逻辑。对这几个方法有疑惑的同学，可以阅读《给 Android 开发者的 RxJava 详解》「 3) Subscribe (订阅) 」。

5. HystrixCachedObservable

com.netflix.hystrix.HystrixCachedObservable ，缓存 Observable 。

HystrixCachedObservable 构造方法，代码如下：

public class HystrixCachedObservable<R> {
  /**
   * 订阅
   */
  protected final Subscription originalSubscription;
  /**
   * 缓存 cachedObservable
   */
  protected final Observable<R> cachedObservable;
 /**
  * TODO 【2006】【outstandingSubscriptions】
  */
 private volatile int outstandingSubscriptions = 0;
 //private AtomicInteger outstandingSubscriptions2 = new AtomicInteger(0);
 
 protected HystrixCachedObservable(final Observable<R> originalObservable) {
     ReplaySubject<R> replaySubject = ReplaySubject.create();
     this.originalSubscription = originalObservable
             .subscribe(replaySubject);
 
     this.cachedObservable = replaySubject
             .doOnUnsubscribe(new Action0() {
                 @Override
                 public void call() {
                     outstandingSubscriptions--;
                     if (outstandingSubscriptions == 0) {
                         originalSubscription.unsubscribe();
                     }
                 }
             })
             .doOnSubscribe(new Action0() {
                 @Override
                 public void call() {
                     outstandingSubscriptions++;
                 }
             });
 }

第 17 至 19 行：实际上，HystrixCachedObservable 不是一个 Observable 的子类，而是对传入的 Observable 封装：使用 ReplaySubject 向传入的 Observable 发起订阅，通过 ReplaySubject 能够重放执行结果，从而实现缓存的功效。这里有几个卡到笔者的并且很有趣的点，我们一一道来：从上文中，我们可以看到，传入的 originalObservable 为 hystrixObservable 执行命令 Observable 。在 Hystrix 里，提供了两种执行命令的隔离方式：线程池( THREAD ) 和信号量( SEMAPHORE )。

当使用 THREAD 隔离时，#subscribe(replaySubject) 调用完成时，实际命令并未开始执行，或者说，这是一个异步的执行命令的过程。那么，会不会影响返回执行结果呢？答案当然是不会，BlockingObservable 在得到执行完成才会结束阻塞，此时已经有执行结果。
当使用 SEMAPHORE 隔离时，#subscribe(replaySubject) 调用完成时，实际命令已经执行完成，所以即使 AbstractCommand#toObservavle(...) 的第 75 行：调用 HystrixCommandResponseFromCache#unsubscribe() 方法，也会浪费，重复执行命令。而对于 THREAD 隔离的情况，通过取消订阅的方式，只会执行一次命令。当然，如果“恶搞” THREAD 隔离的情况，增加 sleep 的调用如下，就能达到重复执行命令的效果。

第 21 至 36 行：TODO 【2006】【outstandingSubscriptions】原子性没问题么？历史版本使用的是 AtomicInteger 。

HystrixCachedObservable 的其他方法，点击链接查看。

6. HystrixCommandResponseFromCache

com.netflix.hystrix.HystrixCommandResponseFromCache ，是 HystrixCachedObservable 的子类。在父类的基础上，增加了对 AbstractCommand.executionResult 的关注。

HystrixCachedObservable#from(Observable, AbstractCommand) 方法，创建 HystrixCommandResponseFromCache 对象，点击链接查看。

HystrixCommandResponseFromCache#toObservableWithStateCopiedInto(...) 方法，点击链接查看。

通过 completionLogicRun 属性，保证 #doOnError() ，#doOnCompleted() ，#doOnUnsubscribe() 方法有且只有一个方法执行具体逻辑。
- #doOnError() ，#doOnCompleted() 执行时，调用 #commandCompleted() 方法，从缓存命令( HystrixCommandResponseFromCache.originalCommand ) 复制 executionResult 属性给当前命令( commandToCopyStateInto ) 。
- #doOnUnsubscribe() 执行时，调用 #commandUnsubscribed() 方法，使用当前命令( commandToCopyStateInto )自己的 executionResult ，不进行复制。

高并发神器Hystrix源码阅读 —— 执行结果缓存