public class GetUserAccountCommand extends HystrixCommand<UserAccount> {
  ...
    @Override
    protected UserAccount run() {
        /* 模拟执行网络调用以检索用户信息 */
        try {
            Thread.sleep((int) (Math.random() * 10) + 2);
        } catch (InterruptedException e) {
        }
        /* 5％的时间失败来说明fallback的工作原理 */
        if (Math.random() > 0.95) {
            throw new RuntimeException("random failure processing UserAccount network response");
        }
        /* 延迟会增加5％的时间，因此有时会触发超时 */
        if (Math.random() > 0.95) {
            // 随机等待时间尖峰
            try {
                Thread.sleep((int) (Math.random() * 300) + 25);
            } catch (InterruptedException e) {
            }
        }
        /* 成功...使用远程服务响应的数据创建UserAccount */
        return new UserAccount(86975, "John James", 2, true, false, true);
    }
  ...
}

    /**
     * 用于同步执行 command.
     * 
     * @return R
     *         如果command由于任何原因失败，则执行 #run 或从 #getFallback() fallback的结果.
     *
     * @throws HystrixRuntimeException
     *             如果发生故障并且无法检索fallback
     * @throws HystrixBadRequestException
     *             如果使用了无效的参数或状态来表示用户故障，而不是系统故障
     *
     * @throws IllegalStateException
     *             如果多次调用
     */
    public R execute() {
        try {
            return queue().get();
        } catch (Exception e) {
            throw Exceptions.sneakyThrow(decomposeException(e));
        }
    }

    /**
     * 用于异步执行命令 command.
     *
     * 这将使该command在线程池上排队，并在完成后返回一个 Future 以获取结果.
     * 注意：如果配置为不在单独的线程中运行，则其效果与 #execute() 相同，并会阻塞.
     * 不会抛出异常，而只是切换为同步执行，因此无需更改代码即可 将command从运行在单独的线程切换到调用线程.
     * (switch a command from running on a separate thread to the calling thread.)
     * 
     * @return {@code Future <R>}执行 #run() 的结果，或者如果command由于任何原因失败，则返回 #getFallback() 的结果.
     * @throws HystrixRuntimeException
     *             如果不存在fallback
     *             如果通过 ExecutionException＃getCause() 中的{@code Future.get(), 如果不存在失败发生的话
     *             或者如果无法将命令排队(如，短路，线程池/信号被拒绝）,则立即返回
     * @throws HystrixBadRequestException
     *         通过 ExecutionException＃getCause() 中的 Future.get() 如果使用了无效的参数或状态来表示用户故障而不是系统故障
     * @throws IllegalStateException
     *             如果多次调用
     */
    public Future<R> queue() {
        /*
         * 当Future.cancel（boolean）的“ mayInterrupt”标志设为true时
         * 由Observable.toBlocking().toFuture() 返回的Future不实现执行线程的中断
         * 因此，为了遵守Future的约定，我们必须围绕它.
         */
        final Future<R> delegate = toObservable().toBlocking().toFuture();
        final Future<R> f = new Future<R>() {
            @Override
            public boolean cancel(boolean mayInterruptIfRunning) {
                if (delegate.isCancelled()) {
                    return false;
                }
                if (HystrixCommand.this.getProperties().executionIsolationThreadInterruptOnFutureCancel().get()) {
                    /*
                     * The most consistent way to deal with this scenario is to say that if *any* cancellation is invoked with interruption,
                     * than that interruption request cannot be taken back.
                     * 这里唯一有效的转换是false -> true.
                     * 如果存在由该命令创建(这很奇怪，但从未禁止过)的两个futures,例如f1和f2，
                     * 并且对f1.cancel(true)和f2.cancel(false)的调用是由不同的线程发起,
                     * 尚不清楚在检查mayInterruptOnCancel时将使用什么值.
                     * 处理这种情况的最一致的方法是说，如果在中断的情况下调用了任何cancellation,则无法撤回该中断请求.
                     */
                    interruptOnFutureCancel.compareAndSet(false, mayInterruptIfRunning);
            }
                final boolean res = delegate.cancel(interruptOnFutureCancel.get());
                if (!isExecutionComplete() && interruptOnFutureCancel.get()) {
                    final Thread t = executionThread.get();
                    if (t != null && !t.equals(Thread.currentThread())) {
                        t.interrupt();
                    }
                }
                return res;
      }
            @Override
            public boolean isCancelled() {
                return delegate.isCancelled();
      }
            @Override
            public boolean isDone() {
                return delegate.isDone();
      }
            @Override
            public R get() throws InterruptedException, ExecutionException {
                return delegate.get();
            }
            @Override
            public R get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
                return delegate.get(timeout, unit);
            }
        };
        /* 对立即抛出的错误状态的特殊处理 */
        if (f.isDone()) {
            try {
                f.get();
                return f;
            } catch (Exception e) {
                Throwable t = decomposeException(e);
                if (t instanceof HystrixBadRequestException) {
                    return f;
                } else if (t instanceof HystrixRuntimeException) {
                    HystrixRuntimeException hre = (HystrixRuntimeException) t;
                    switch (hre.getFailureType()) {
          case COMMAND_EXCEPTION:
          case TIMEOUT:
                        // 不会仅从 queue().get() 中将这些类型从 queue() 中抛出, 因为它们是执行错误
            return f;
          default:
            // these are errors we throw from queue() as they as rejection type errors
                        // 这些是从 queue() 抛出的错误，因为它们是拒绝类型错误
            throw hre;
          }
                } else {
                    throw Exceptions.sneakyThrow(t);
                }
            }
        }
        return f;
    }

K             value   = command.execute();
Future<K>     fValue  = command.queue();
Observable<K> ohValue = command.observe();         
Observable<K> ocValue = command.toObservable();