if (executeImmediate) {
        new RunnableExecutorPair(runnable, executor).execute();
      }
    }

    void execute() {
      synchronized (runnables) {
        if (executed) {
          return;
        }
        executed = true;
      }

      while (!runnables.isEmpty()) {
        runnables.poll().execute();
      }
    }

    private static class RunnableExecutorPair {

 * that every {@code Runnable} that is {@linkplain #add added} will be executed after {@link
 * #execute()} is called. Any {@code Runnable} added after the call to {@code execute} is still
 * guaranteed to execute. There is no guarantee, however, that listeners will be executed in the
 * order that they are added.
 *

   *
   * @throws IOException if the request could not be executed due to cancellation, a connectivity
   *     problem or timeout. Because networks can fail during an exchange, it is possible that the
   *     remote server accepted the request before the failure.
   * @throws IllegalStateException when the call has already been executed.
   */
  @Throws(IOException::class)
  fun execute(): Response

  /**

                    logger.debug("Process {} is already executed.", p);
                }
            }
        }

        /**
         * Checks if the destroyer has been executed.
         * @return True if executed, false otherwise.
         */
        public boolean isExecuted() {
            return executed.get();
        }
    }

    /**

# Lifespan Events { #lifespan-events }

You can define logic (code) that should be executed before the application **starts up**. This means that this code will be executed **once**, **before** the application **starts receiving requests**.

The same way, you can define logic (code) that should be executed when the application is **shutting down**. In this case, this code will be executed **once**, **after** having handled possibly **many requests**.

 *   It is similar to a Promise in JavaScript.
 *   It allows you to register callbacks that will be executed when the computation is complete,
 *   either successfully (resolve) or with an error (reject).
 * </p>
 *
 * <p>
 *   The Deferred class has a Promise inner class that allows you to register callbacks
 *   to be executed when the computation is complete.

     */
    void setInitParameterMap(Map<String, Object> params);

    /**
     * Executes a request and returns the response data.
     *
     * @param data the request data to be executed
     * @return the response data from the executed request
     */
    ResponseData execute(RequestData data);

    /**
     * Closes the crawler client and releases any resources associated with it.

These dependencies will be executed/solved the same way as normal dependencies. But their value (if they return any) won't be passed to your *path operation function*.

/// tip

Some editors check for unused function parameters, and show them as errors.

Using these `dependencies` in the *path operation decorator* you can make sure they are executed while avoiding editor/tooling errors.

     */
    @Required
    public String target;

    /**
     * The type of script that was executed for this job.
     * This is a required field indicating the script engine or type used.
     */
    @Required
    public String scriptType;

    /**
     * The script data or code that was executed.
     * This field contains the actual script content that was run.
     */
    public String scriptData;

    }

    eventListener.canceled(this)
  }

  override fun isCanceled(): Boolean = canceled

  override fun execute(): Response {
    check(executed.compareAndSet(false, true)) { "Already Executed" }

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