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

        // 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);

     * 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.

   *
   * <p>Triggers test case failure if interrupt status is set in the main thread.
   */
  @Override
  public void tearDown() throws Exception {
    Throwable t = threadFailure.getAndSet(null);
    if (t != null) {
      if (t instanceof Error) throw (Error) t;
      else if (t instanceof RuntimeException) throw (RuntimeException) t;
      else if (t instanceof Exception) throw (Exception) t;