}
    }

    /**
     * Sets the thread pool for executing the request.
     *
     * @param threadPool the thread pool
     * @return this CurlRequest instance
     */
    public CurlRequest threadPool(final ForkJoinPool threadPool) {
        this.threadPool = threadPool;
        return this;
    }

    /**
     * Sets the connection and read timeouts for the request.
     *

     * @param settings The suggest settings.
     * @param threadPool The thread pool.
     */
    public SuggestIndexer(final Client client, final String index, final ReadingConverter readingConverter,
            final ReadingConverter contentsReadingConverter, final Normalizer normalizer, final SuggestAnalyzer analyzer,
            final SuggestSettings settings, final ExecutorService threadPool) {
        this.client = client;

        To be awaitable, compatible with async, this is run in threadpool.
        """
        return await super().seek(offset)

    async def close(self) -> None:
        """
        Close the file.

        To be awaitable, compatible with async, this is run in threadpool.
        """
        return await super().close()

    @classmethod

            final boolean parallel) {
        this.client = client;
        this.settings = settings;
        this.threadPool = threadPool;
        this.indexingOps = indexingOps;
        this.contentsParser = contentsParser;
        this.analyzer = analyzer;
        this.readingConverter = readingConverter;
        this.contentsReadingConverter = contentsReadingConverter;
        this.normalizer = normalizer;

///

### Path operation functions { #path-operation-functions }

When you declare a *path operation function* with normal `def` instead of `async def`, it is run in an external threadpool that is then awaited, instead of being called directly (as it would block the server).

        ForkJoinPool pool1 = new ForkJoinPool(2);
        ForkJoinPool pool2 = new ForkJoinPool(4);

        // Multiple threadPool calls should work
        request.threadPool(pool1);
        request.threadPool(pool2);

        assertNotNull(request);
    }

    @Test
    public void testOnConnectWithNull() {

        ForkJoinPool pool = new ForkJoinPool(1);
        req.threadPool(pool);

        // ## Act ##
        // execute() should force synchronous execution but restore threadPool afterward
        try (CurlResponse response = req.execute()) {
            assertEquals(200, response.getHttpStatusCode());
        }

        // ## Assert ##
        // After execute(), the threadPool should be restored

    ExecutorService threadPool = newFixedThreadPool(nThreads);
    CountDownLatch tasksFinished = new CountDownLatch(nTasks);
    for (int i = 0; i < nTasks; i++) {
      String s = "a" + i;
      @SuppressWarnings("unused") // https://errorprone.info/bugpattern/FutureReturnValueIgnored
      Future<?> possiblyIgnoredError =
          threadPool.submit(
              () -> {

    ExecutorService threadPool = newFixedThreadPool(nThreads);
    CountDownLatch tasksFinished = new CountDownLatch(nTasks);
    for (int i = 0; i < nTasks; i++) {
      String s = "a" + i;
      @SuppressWarnings("unused") // https://errorprone.info/bugpattern/FutureReturnValueIgnored
      Future<?> possiblyIgnoredError =
          threadPool.submit(
              () -> {

///

To avoid blocking the event loop, you can simply declare the *path operation function* with regular `def` instead of `async def`, that way FastAPI will run it on a threadpool worker, to avoid blocking the main loop.

{* ../../docs_src/stream_data/tutorial002_py310.py ln[30:34] hl[31] *}

/// tip