if (existing != null) {
        return existing;
      }
      L created = supplier.get();
      ArrayReference<L> newRef = new ArrayReference<>(created, index, queue);
      while (!locks.compareAndSet(index, existingRef, newRef)) {
        // we raced, we need to re-read and try again
        existingRef = locks.get(index);
        existing = existingRef == null ? null : existingRef.get();

        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;
            }

     * @return the response data
     * @throws CrawlingAccessException if the request fails
     */
    protected ResponseData processRequest(final String uri, final boolean includeContent) {
        if (isInit.compareAndSet(false, true)) {
            init();
        }

        // start
        AccessTimeoutTarget accessTimeoutTarget = null;
        TimeoutTask accessTimeoutTask = null;
        if (accessTimeout != null) {

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

          "Expected status to be %s, but it was %s",
          oldStatus,
          newStatus);
    }

    boolean compareAndUpdateStatus(Status oldStatus, Status newStatus) {
      return status.compareAndSet(oldStatus, newStatus);
    }

    void close() {
      logger.get().log(FINER, "closing {0}", closingFutureToString());
      closeables.close();
    }

    val ifNoneMatch = AtomicReference<String?>()
    client =
      client
        .newBuilder()
        .addNetworkInterceptor(
          Interceptor { chain: Interceptor.Chain ->
            ifNoneMatch.compareAndSet(null, chain.request().header("If-None-Match"))
            chain.proceed(chain.request())
          },
        ).build()

    // Confirm the value is cached and intercepted.