public void testFinishToFuture_throwsIfCalledTwice() throws Exception {
    ClosingFuture<Closeable> closingFuture =
        ClosingFuture.submit(closer -> closer.eventuallyClose(mockCloseable, executor), executor);
    FluentFuture<Closeable> unused = closingFuture.finishToFuture();
    assertThrows(
        IllegalStateException.class,
        () -> {
          FluentFuture<Closeable> unused2 = closingFuture.finishToFuture();

        super.tearDown(testInfo);
    }

    @Test
    public void test_constructor() {
        // Test that constructor creates an instance
        ScriptExecutor executor = new ScriptExecutor();
        assertNotNull(executor);
        assertTrue(executor instanceof JobExecutor);
    }

    @Test
    public void test_execute_withValidScriptType() {
        // Setup test script engine

   *
   * <p>RuntimeExceptions thrown by a listener will be caught and logged. Any exception thrown
   * during {@code Executor.execute} (e.g., a {@code RejectedExecutionException}) will be caught and
   * logged.
   *
   * @param listener the listener to run when the service changes state is complete
   * @param executor the executor in which the listeners callback methods will be run. For fast,

 * For restrictions, please refer to the documentation of the then() method.
 */
public interface ListenableFuture<V extends @Nullable Object> extends Future<V>, IThenable<V> {
  void addListener(Runnable listener, Executor executor);

  /** Note that this method is not expected to be overridden. */
  @JsMethod
  @Override
  default <R extends @Nullable Object> IThenable<R> then(

        }
      }
    }
  }

  /**
   * Checks if the executor has been shut down and increments the running task count.
   *
   * @throws RejectedExecutionException if the executor has been previously shutdown
   */
  private void startTask() {
    synchronized (lock) {
      if (shutdown) {
        throw new RejectedExecutionException("Executor already shutdown");
      }
      runningTasks++;
    }
  }

    TFE_DeleteContextOptions(opts);
    TFE_Executor* executor = TFE_NewExecutor(
        /*is_async=*/false, /*enable_streaming_enqueue=*/true,
        /*in_flight_nodes_limit=*/0);
    TFE_ContextSetExecutorForThread(ctx, executor);

    TFE_DeleteContext(ctx);
    TFE_DeleteExecutor(executor);
  }

  {
    TFE_ContextOptions* opts = TFE_NewContextOptions();

   * CacheLoader#reload} using {@code executor}.
   *
   * <p>This method is useful only when {@code loader.reload} has a synchronous implementation, such
   * as {@linkplain #reload the default implementation}.
   *
   * @since 17.0
   */
  @GwtIncompatible // Executor + Futures
  public static <K, V> CacheLoader<K, V> asyncReloading(
      CacheLoader<K, V> loader, Executor executor) {
    checkNotNull(loader);

  }

  public void testTimeout() throws Exception {
    // Create a service whose executor will never run its commands
    Service service =
        new TestService() {
          @Override
          protected Executor executor() {
            return new Executor() {
              @Override
              public void execute(Runnable command) {}
            };
          }

    private final BuildPlanExecutor executor;
    private final LifecyclePluginResolver lifecyclePluginResolver;
    private final MojoDescriptorCreator mojoDescriptorCreator;

    @Inject
    public ConcurrentLifecycleStarter(
            ExecutionEventCatapult eventCatapult,
            DefaultLifecycles defaultLifeCycles,
            BuildPlanExecutor executor,
            LifecyclePluginResolver lifecyclePluginResolver,

///

Para evitar bloquear o loop de eventos, você pode simplesmente declarar a função de operação de rota com `def` normal em vez de `async def`. Assim, o FastAPI a executará em um worker de threadpool, evitando bloquear o loop principal.

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

/// tip | Dica