return failFastResponse!!
    }

    val result = responseQueue.take()

    // If take() returned because we're shutting down, then enqueue another dead letter so that any
    // other threads waiting on take() will also return.
    if (result == DEAD_LETTER) responseQueue.add(DEAD_LETTER)

    return result
  }

  override fun peek(): MockResponse {

apiVersion: release-notes/v2
kind: feature
area: traffic-management
issue:
  - 18152

releaseNotes:
- |

        final TimeValue interval = TimeValue.parseTimeValue(fessConfig.getCrawlerHotthreadInterval(), "crawler.hotthread.interval");
        final int threads = fessConfig.getCrawlerHotthreadThreadsAsInteger();
        final String timeout = fessConfig.getCrawlerHotthreadTimeout();
        final String type = fessConfig.getCrawlerHotthreadType();
        try {

    private final Property<Integer> threads;

    public PmdExtension(Project project) {
        this.project = project;
        this.rulesMinimumPriority = project.getObjects().property(Integer.class);
        this.incrementalAnalysis = project.getObjects().property(Boolean.class);
        this.maxFailures = project.getObjects().property(Integer.class);
        this.threads = project.getObjects().property(Integer.class);

     */
    @Nullable
    ResourceLockState getCurrent();

    /**
     * Attempts to atomically change the state of resource locks.  Only one thread can alter the resource lock
     * states at one time.  Other threads will block until the resource lock state is free.  The provided
     * {@link InternalTransformer} should return a {@link org.gradle.internal.resources.ResourceLockState.Disposition}

	rlimit := &statsapi.RlimitStats{}

	taskMax := int64(-1)
	// Calculate the minimum of kernel.pid_max and kernel.threads-max as they both specify the
	// system-wide limit on the number of tasks.
	for _, file := range []string{"/proc/sys/kernel/pid_max", "/proc/sys/kernel/threads-max"} {
		if content, err := os.ReadFile(file); err == nil {
			if limit, err := strconv.ParseInt(string(content[:len(content)-1]), 10, 64); err == nil {

  /// thread when coordinator is set. If there is no coordinator it should be
  /// called before calling Join.
  void Stop(Session* sess);

  /// Joins all the threads. Returns okay if all threads run successfully;
  /// otherwise returns the first captured failure status.
  Status Join() final;

  /// Returns the latest status.
  Status GetStatus();

  // Returns the stored cost model.

 * (method {@link #add}) are contended across threads, the set of variables may grow dynamically to
 * reduce contention. Method {@link #sum} (or, equivalently, {@link #longValue}) returns the current
 * total combined across the variables maintaining the sum.
 *
 * <p>This class is usually preferable to {@link AtomicLong} when multiple threads update a common

 * (method {@link #add}) are contended across threads, the set of variables may grow dynamically to
 * reduce contention. Method {@link #sum} (or, equivalently, {@link #longValue}) returns the current
 * total combined across the variables maintaining the sum.
 *
 * <p>This class is usually preferable to {@link AtomicLong} when multiple threads update a common

apiVersion: release-notes/v2
kind: feature
area: traffic-management

releaseNotes:
- |
  **Added** an experimental feature to enable cluster creation on worker threads inline during requests.
  This will save memory and CPU cycles in cases where there are lots of inactive clusters and > 1 worker thread.