*
   * <p>This method waits 120 seconds before continuing with JVM termination, even if the executor
   * has not finished its work.
   *
   * <p>This is mainly for fixed thread pools. See {@link Executors#newFixedThreadPool(int)}.
   *
   * @param executor the executor to modify to make sure it exits when the application is finished
   * @return an unmodifiable version of the input which will not hang the JVM
   */
  @J2ktIncompatible

  private val readyAsyncCalls = ArrayDeque<AsyncCall>()

  /** Running asynchronous calls. Includes canceled calls that haven't finished yet. */
  private val runningAsyncCalls = ArrayDeque<AsyncCall>()

  /** Running synchronous calls. Includes canceled calls that haven't finished yet. */
  private val runningSyncCalls = ArrayDeque<RealCall>()

  constructor(executorService: ExecutorService?) : this() {

                    // Process finished normally.
                    final int exitValue = p.exitValue();
                    if (exitValue != 0) {
                        logger.warn("{} failed: exitCode={}, command={}", getName(), exitValue, commandList);
                    }

                    if (logger.isDebugEnabled()) {
                        logger.debug("{} finished: exitCode={}", getName(), exitValue);

                    }
                }
            }
        }

        /**
         * Sets the finished flag.
         * @param finished The finished flag to set.
         */
        public void setFinished(final boolean finished) {
            this.finished = finished;
        }

        /**
         * Returns whether the process was terminated.

                }
            }
        }

        /**
         * Sets the finished flag to indicate whether the process has completed.
         * @param finished True if the process has finished, false otherwise.
         */
        public void setFinished(final boolean finished) {
            this.finished = finished;
        }

        /**
         * Checks if the process has been terminated due to timeout.

        /** Initialization parameters for the data store */
        private final DataStoreParams initParamMap;

        /** Flag indicating whether the crawling thread has finished execution */
        protected boolean finished = false;

        /** Flag indicating whether the crawling thread is currently running */
        protected boolean running = false;

            }
            forceStop();
        }
    }

    /**
     * Adds a finished session ID to the cleanup list.
     * This method is thread-safe and adds the session ID to be cleaned up later.
     *
     * @param sessionId the crawler session ID that has finished processing
     */
    public void addFinishedSessionId(final String sessionId) {
        synchronized (finishedSessionIdList) {

                if (scheduledJob.isLoggingEnabled() && logger.isInfoEnabled()) {
                    logger.info("Finished job: id={}", id);
                }
            } else {
                if (scheduledJob.isLoggingEnabled() && logger.isInfoEnabled()) {
                    logger.info("Finished job: id={}, returnValue:\n{}", id, ret);
                }
                jobLog.setScriptResult(ret.toString());
            }

            logger.debug("No ResponseProcessor for ({}, {}). PLEASE CHECK YOUR CONFIGURATION.", responseData.getUrl(),
                    responseData.getMimeType());
        }
    }

    /**
     * Processes finished thread log events.
     *
     * @param objs the log objects
     */
    protected void processFinishedThread(final Object... objs) {
        // CrawlerContext crawlerContext = (CrawlerContext) objs[0];
    }

    timeout.enter()
    callStart()
    try {
      client.dispatcher.executed(this)
      return getResponseWithInterceptorChain()
    } finally {
      client.dispatcher.finished(this)
    }
  }

  override fun enqueue(responseCallback: Callback) {
    check(executed.compareAndSet(false, true)) { "Already Executed" }

    callStart()