long newValue;
      do {
        oldValue = data.get(longIndex);
        newValue = oldValue | mask;
        if (oldValue == newValue) {
          return false;
        }
      } while (!data.compareAndSet(longIndex, oldValue, newValue));

      // We turned the bit on, so increment bitCount.
      bitCount.increment();
      return true;
    }

    boolean get(long bitIndex) {

      }
    } finally {
      readCompleteLatch.countDown()
    }
  }

  abstract fun listSource(): Source

  override fun ensureLoaded() {
    if (!listRead.get() && listRead.compareAndSet(false, true)) {
      readTheListUninterruptibly()
    } else {
      try {
        readCompleteLatch.await()
      } catch (_: InterruptedException) {

    for (int i = 0; i < 10; i++) {
      int expectedCount = i;
      list.add(
          new Runnable() {
            @Override
            public void run() {
              integer.compareAndSet(expectedCount, expectedCount + 1);
            }
          },
          directExecutor());
    }
    list.execute();
    assertEquals(10, integer.get());
  }

            log.trace("Acquire session " + usage + " " + this);
        }

        if (usage == 1) {
            synchronized (this) {
                if (this.transportAcquired.compareAndSet(false, true)) {
                    log.debug("Reacquire transport");
                    this.transport.acquire();
                }
            }
        }

        return this;
    }

        while (responseTimeMs < currentMin) {
            if (minResponseTime.compareAndSet(currentMin, responseTimeMs)) {
                break;
            }
            currentMin = minResponseTime.get();
        }

        long currentMax = maxResponseTime.get();
        while (responseTimeMs > currentMax) {
            if (maxResponseTime.compareAndSet(currentMax, responseTimeMs)) {
                break;
            }

            }
        }

        if (usage == 1) {
            synchronized (this) {
                if (this.sessionAcquired.compareAndSet(false, true)) {
                    log.debug("Reacquire session");
                    this.session.acquire();
                }
            }
        }
        return this;
    }

    /**

      executionList.add(listener, exec);

      // When a listener is first added, we run a task that will wait for the delegate to finish,
      // and when it is done will run the listeners.
      if (hasListeners.compareAndSet(false, true)) {
        if (delegate.isDone()) {
          // If the delegate is already done, run the execution list immediately on the current
          // thread.
          executionList.execute();

        executingTaskQueue.thread = null;
      }
    }

    private boolean trySetStarted() {
      return compareAndSet(NOT_RUN, STARTED);
    }

    private boolean trySetCancelled() {
      return compareAndSet(NOT_RUN, CANCELLED);
    }
  }

    check(executed.compareAndSet(false, true)) { "Already Executed" }

    timeout.enter()
    callStart()
    try {
      client.dispatcher.executed(this)
      return getResponseWithInterceptorChain()
    } finally {
      client.dispatcher.finished(this)
    }
  }

  override fun enqueue(responseCallback: Callback) {
    check(executed.compareAndSet(false, true)) { "Already Executed" }

                if (logger.isDebugEnabled()) {
                    logger.debug("Process {} is not alive.", p);
                }
                return;
            }

            if (executed.compareAndSet(false, true)) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Interrupting a stream thread.");
                }
                ist.interrupt();