if (cleanupTask != null) {
            cleanupTask.cancel(false);
        }

        // Force cleanup of all resources
        int cleaned = forceCleanup();

        // Shutdown executor
        cleanupExecutor.shutdown();
        try {
            if (!cleanupExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
                cleanupExecutor.shutdownNow();
            }

      get() = originalRequest

    val call: RealCall
      get() = this@RealCall

    /**
     * Attempt to enqueue this async call on [executorService]. This will attempt to clean up
     * if the executor has been shut down by reporting the call as failed.
     */
    fun executeOn(executorService: ExecutorService) {
      client.dispatcher.assertLockNotHeld()

      var success = false
      try {

=== ":material-language-kotlin: Kotlin"
    ```kotlin
      private val executor = Executors.newScheduledThreadPool(1)
      private val client = OkHttpClient()

      fun run() {
        val request = Request.Builder()

      if (activeTask == null && futureTasks.isEmpty()) {
        return CountDownLatch(0)
      }

      // If there's an existing AwaitIdleTask, use it. This is necessary when the executor is
      // shutdown but still busy as we can't enqueue in that case.
      val existingTask = activeTask
      if (existingTask is AwaitIdleTask) {
        return existingTask.latch
      }

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Executor;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Executor;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;

#### Do-stuff-later pool

Sometimes there's an action required like calling the application layer or responding to a ping, and the thread discovering the action is not the thread that should do the work. We enqueue a runnable on this executor and it gets handled by one of the executor's threads.

### Locks

We have 3 different things that we synchronize on.

#### Http2Connection

        thumbnailQueueBhv.batchInsert(list);
    }

    /**
     * Generates thumbnails using the provided executor service.
     *
     * @param executorService the executor service for parallel processing
     * @param cleanup whether to run in cleanup mode
     * @return the number of tasks processed
     */

        String result = pythonJob.execute();

        assertTrue(result.contains("Session Id:"));
        assertTrue(result.contains("Python Process terminated."));
    }

    // Test execute with job executor
    public void test_execute_withJobExecutor() {
        pythonJob.filename("test.py");

        TestJobExecutor jobExecutor = new TestJobExecutor();
        pythonJob.jobExecutor = jobExecutor;

     */
    requireNonNull(futures);

    // Corner case: List is empty.
    if (futures.isEmpty()) {
      handleAllCompleted();
      return;
    }

    // NOTE: If we ever want to use a custom executor here, have a look at CombinedFuture as we'll
    // need to handle RejectedExecutionException

    if (allMustSucceed) {
      // We need fail fast, so we have to keep track of which future failed so we can propagate