from typing import TypeVar

import anyio.to_thread
from anyio import CapacityLimiter
from starlette.concurrency import iterate_in_threadpool as iterate_in_threadpool  # noqa
from starlette.concurrency import run_in_threadpool as run_in_threadpool  # noqa
from starlette.concurrency import (  # noqa
    run_until_first_complete as run_until_first_complete,
)

_T = TypeVar("_T")


@asynccontextmanager

 * @since 10.0
 */
@GwtCompatible
public final class Uninterruptibles {
  /** Invokes {@code latch.}{@link CountDownLatch#await() await()} uninterruptibly. */
  @J2ktIncompatible
  @GwtIncompatible // concurrency
  public static void awaitUninterruptibly(CountDownLatch latch) {
    boolean interrupted = false;
    try {
      while (true) {
        try {
          latch.await();
          return;

### Concurrency and Burgers { #concurrency-and-burgers }

This idea of **asynchronous** code described above is also sometimes called **"concurrency"**. It is different from **"parallelism"**.

**Concurrency** and **parallelism** both relate to "different things happening more or less at the same time".

But the details between *concurrency* and *parallelism* are quite different.

    FakeTicker ticker = new FakeTicker();
    assertThrows(
        IllegalArgumentException.class, () -> ticker.setAutoIncrementStep(-1, NANOSECONDS));
  }

  @GwtIncompatible // concurrency

  public void testConcurrentAdvance() throws Exception {
    FakeTicker ticker = new FakeTicker();

    int numberOfThreads = 64;
    runConcurrentTest(
        numberOfThreads,
        () -> {

    FakeTicker ticker = new FakeTicker();
    assertThrows(
        IllegalArgumentException.class, () -> ticker.setAutoIncrementStep(-1, NANOSECONDS));
  }

  @GwtIncompatible // concurrency

  public void testConcurrentAdvance() throws Exception {
    FakeTicker ticker = new FakeTicker();

    int numberOfThreads = 64;
    runConcurrentTest(
        numberOfThreads,
        () -> {

    /**
     * Gets the timeout for waiting to acquire a concurrency permit (ms).
     * Default is 30000ms. Override or configure via rag.llm.{provider}.concurrency.wait.timeout.
     *
     * @return the wait timeout in milliseconds
     */
    protected long getConcurrencyWaitTimeoutMs() {
        return Long.parseLong(ComponentUtil.getFessConfig().getOrDefault(getConfigPrefix() + ".concurrency.wait.timeout", "30000"));
    }

    /**

  }

  /**
   * Guides the allowed concurrency among update operations. Used as a hint for internal sizing. The
   * table is internally partitioned to try to permit the indicated number of concurrent updates
   * without contention. Because assignment of entries to these partitions is not necessarily
   * uniform, the actual concurrency observed may vary. Ideally, you should choose a value to

import org.jspecify.annotations.Nullable;

/**
 * A helper for concurrency testing. One or more {@code TestThread} instances are instantiated in a
 * test with reference to the same "lock-like object", and then their interactions with that object
 * are choreographed via the various methods on this class.
 *
 * <p>A "lock-like object" is really any object that may be used for concurrency control. If the

 * </p>
 * <pre>
 * Map&lt;K, V&gt; syncMap = Collections.synchronizedMap(new LruHashMap&lt;&gt;(100));
 * </pre>
 * <p>
 * Alternatively, for high-concurrency scenarios, consider implementing a custom
 * LRU cache using {@link java.util.concurrent.ConcurrentHashMap} with an eviction strategy.
 * </p>
 *
 * @author koichik
 * @param <K> the key type

# ==============================================================================
name: CI

on:
  pull_request:
    branches:
      - master
      - r2.**

permissions:
  contents: read

concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.ref }}
  # Don't cancel in-progress jobs for master branches.
  cancel-in-progress: ${{ github.ref != 'master' }}

jobs:
  #build-and-test-linux-x86-cpu: