if (waitForState(transport) == 2) {
                    // already connected
                    return null;
                }
                final int before = this.connectionState.getAndSet(1);
                if (before == 1) {
                    // concurrent connection attempt
                    if (waitForState(transport) == 2) {
                        // finished connecting

        log.info("Circuit breaker {} reset", name);
    }

    /**
     * Force the circuit to open
     */
    public void tripBreaker() {
        State previous = state.getAndSet(State.OPEN);
        if (previous != State.OPEN) {
            stateChangeTime.set(System.currentTimeMillis());
            lastFailureTime.set(System.currentTimeMillis());

        // not all.  See the test cases for examples on how this can happen.
        try {
          ((Thread) currentRunner).interrupt();
        } finally {
          Runnable prev = getAndSet(DONE);
          if (prev == PARKED) {
            LockSupport.unpark((Thread) currentRunner);
          }
        }
      }
    }
  }

  /**

        while (resultWithDoubleSelfLoop.hasNext()) {
          EndpointPair<N> edge = resultWithDoubleSelfLoop.next();
          if (edge.nodeU().equals(edge.nodeV())) {
            if (!alreadySeenSelfLoop.getAndSet(true)) {
              return edge;
            }
          } else {
            return edge;
          }
        }
        return endOfData();
      }
    };
  }

        return timeSinceLastFailure >= resetTimeoutMillis;
    }

    private void transitionTo(State newState) {
        State oldState = state.getAndSet(newState);
        lastStateChangeTime.set(System.currentTimeMillis());

        if (oldState != newState) {
            log.info("[{}] Circuit breaker state transition: {} -> {}", name, oldState, newState);

     * cancelled before the callable started execution.
     */
    SettableFuture<@Nullable Void> newFuture = SettableFuture.create();

    ListenableFuture<@Nullable Void> oldFuture = ref.getAndSet(newFuture);

    // Invoke our task once the previous future completes.
    TrustedListenableFutureTask<T> taskFuture = TrustedListenableFutureTask.create(task);
    oldFuture.addListener(taskFuture, taskExecutor);

     * It's called both during normal shutdown and in error conditions.
     */
    private static void destroyContainer() {
        if (running.getAndSet(false)) {
            TimeoutManager.getInstance().stop();
            if (logger.isDebugEnabled()) {
                logger.debug("Destroying LaContainer...");
            }

     * @param status The current cluster status.
     * @return true if the state has changed, false otherwise.
     */
    public boolean isChangedClusterState(final int status) {
        return previousClusterState.getAndSet(status) != status;
    }

    /**
     * Creates a new action validator.
     *
     * @param requestManager  The request manager.
     * @param messagesCreator The messages creator.