public Future<R> queue() {/** The Future returned by Observable.toBlocking().toFuture() does not implement the* interruption of the execution thread when the "mayInterrupt" flag of Future.cancel(boolean) is set to true;* thus, to comply with the contract of Future, we must wrap around it.*/final Future<R> delegate = toObservable().toBlocking().toFuture();final Future<R> f = new Future<R>() {@Overridepublic boolean cancel(boolean mayInterruptIfRunning) {if (delegate.isCancelled()) {return false;}if (HystrixCommand.this.getProperties().executionIsolationThreadInterruptOnFutureCancel().get()) {/** The only valid transition here is false -> true. If there are two futures, say f1 and f2, created by this command* (which is super-weird, but has never been prohibited), and calls to f1.cancel(true) and to f2.cancel(false) are* issued by different threads, it's unclear about what value would be used by the time mayInterruptOnCancel is checked.* 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.*/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;}@Overridepublic boolean isCancelled() {return delegate.isCancelled();}@Overridepublic boolean isDone() {return delegate.isDone();}@Overridepublic R get() throws InterruptedException, ExecutionException {return delegate.get();}@Overridepublic R get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {return delegate.get(timeout, unit);}};

threadPool.getScheduler(new Func0<Boolean>() {@Overridepublic Boolean call() {return properties.executionIsolationThreadInterruptOnTimeout().get() && _cmd.isCommandTimedOut.get() == TimedOutStatus.TIMED_OUT;}})

private static class FutureCompleterWithConfigurableInterrupt implements Subscription {private final FutureTask<?> f;private final Func0<Boolean> shouldInterruptThread;private final ThreadPoolExecutor executor;private FutureCompleterWithConfigurableInterrupt(FutureTask<?> f, Func0<Boolean> shouldInterruptThread, ThreadPoolExecutor executor) {this.f = f;this.shouldInterruptThread = shouldInterruptThread;this.executor = executor;}@Overridepublic void unsubscribe() {executor.remove(f);if (shouldInterruptThread.call()) {f.cancel(true);} else {f.cancel(false);}}@Overridepublic boolean isUnsubscribed() {return f.isCancelled();}}