return map.getOrDefault(key, 0L);
  }

  /**
   * Increments by one the value currently associated with {@code key}, and returns the new value.
   */
  @CanIgnoreReturnValue
  public long incrementAndGet(K key) {
    return addAndGet(key, 1);
  }

  /**
   * Decrements by one the value currently associated with {@code key}, and returns the new value.
   */
  @CanIgnoreReturnValue

 */
class TaskQueue internal constructor(
  internal val taskRunner: TaskRunner,
  internal val name: String,
) {
  internal var shutdown = false

  /** This queue's currently-executing task, or null if none is currently executing. */
  internal var activeTask: Task? = null

  /** Scheduled tasks ordered by [Task.nextExecuteNanoTime]. */
  internal val futureTasks = mutableListOf<Task>()

    int NT_STATUS_SHARING_VIOLATION = 0xC0000043;
    /** The file is pending deletion */
    int NT_STATUS_DELETE_PENDING = 0xC0000056;
    /** There are currently no logon servers available to service the logon request */
    int NT_STATUS_NO_LOGON_SERVERS = 0xC000005e;
    /** The specified user already exists */
    int NT_STATUS_USER_EXISTS = 0xC0000063;

    segment = cache.segments[0];
    chain = null;
    for (int i = 0; i < length; i++) {
      Object key = new Object();
      // TODO(b/145386688): This access should be guarded by 'this.segment', which is not currently
      // held
      chain = segment.newEntry(key, cache.hash(key), chain);
      if (i == 0) {
        head = chain;
      }
    }
  }

  @SuppressWarnings("GuardedBy")
  @Benchmark

    if (!isRunning && idleCallback != null) {
      idleCallback.run()
    }
  }

  /** Returns a snapshot of the calls currently awaiting execution. */
  @Synchronized
  fun queuedCalls(): List<Call> = readyAsyncCalls.map { it.call }.unmodifiable()

  /** Returns a snapshot of the calls currently being executed. */
  @Synchronized
  fun runningCalls(): List<Call> = (runningSyncCalls + runningAsyncCalls.map { it.call }).unmodifiable()

   * the queue is currently full.
   *
   * @since 16.0
   */
  public int remainingCapacity() {
    return maxSize - size();
  }

  @Override
  protected Queue<E> delegate() {
    return delegate;
  }

  /**
   * Adds the given element to this queue. If the queue is currently full, the element at the head
   * of the queue is evicted to make room.
   *

    int NT_STATUS_SHARING_VIOLATION = 0xC0000043;
    /** The file is pending deletion */
    int NT_STATUS_DELETE_PENDING = 0xC0000056;
    /** There are currently no logon servers available to service the logon request */
    int NT_STATUS_NO_LOGON_SERVERS = 0xC000005e;
    /** The specified user already exists */
    int NT_STATUS_USER_EXISTS = 0xC0000063;

    protected ThreadUtil() {
    }

    /**
     * Causes the currently executing thread to sleep (temporarily cease execution) for the specified number of milliseconds.
     *
     * @param millis
     *            the length of time to sleep in milliseconds
     * @throws InterruptedRuntimeException
     *             if any thread has interrupted the current thread.
     */
    public static void sleep(final long millis) {

    /**
     * Retrieves web crawling configurations with various filtering options.
     *
     * @param withLabelType whether to include label type information (currently not used in implementation)
     * @param withRoleType whether to include role type information (currently not used in implementation)
     * @param available whether to filter only available configurations

import okhttp3.internal.okHttpName
import okhttp3.internal.threadFactory

/**
 * A set of worker threads that are shared among a set of task queues.
 *
 * Use [INSTANCE] for a task runner that uses daemon threads. There is not currently a shared
 * instance for non-daemon threads.
 *
 * The task runner is also responsible for releasing held threads when the library is unloaded.
 * This is for the benefit of container environments that implement code unloading.