Java Context.executeBlocking方法代码示例

import io.vertx.core.Context; //导入方法依赖的package包/类
/**
 * Returns a new CompletableFuture that is asynchronously completed by a task
 * running in the worker thread pool of Vert.x
 * <p>
 * This method is different from
 * {@link CompletableFuture#supplyAsync(Supplier)} as it does not use a fork
 * join executor, but the worker thread pool.
 *
 * @param context  the context in which the supplier is executed.
 * @param supplier a function returning the value to be used to complete the returned
 *                 CompletableFuture
 * @param <T>      the function's return type
 * @return the new CompletableFuture
 */
public static <T> VertxCompletableFuture<T> supplyBlockingAsync(Context context, Supplier<T> supplier) {
  Objects.requireNonNull(supplier);
  VertxCompletableFuture<T> future = new VertxCompletableFuture<>(context);
  context.<T>executeBlocking(fut -> {
    try {
      fut.complete(supplier.get());
    } catch (Throwable e) {
      fut.fail(e);
    }
  }, ar -> {
    if (ar.failed()) {
      future.completeExceptionally(ar.cause());
    } else {
      future.complete(ar.result());
    }
  });
  return future;
}
 

import io.vertx.core.Context; //导入方法依赖的package包/类
/**
 * Returns a new CompletableFuture that is asynchronously completed by a action running in the worker thread pool of
 * Vert.x
 * <p>
 * This method is different from {@link CompletableFuture#runAsync(Runnable)} as it does not use a fork join
 * executor, but the worker thread pool.
 *
 * @param context  the Vert.x context
 * @param runnable the action, when its execution completes, it completes the returned CompletableFuture. If the
 *                 execution throws an exception, the returned CompletableFuture is completed exceptionally.
 * @return the new CompletableFuture
 */
public static VertxCompletableFuture<Void> runBlockingAsync(Context context, Runnable runnable) {
  Objects.requireNonNull(runnable);
  VertxCompletableFuture<Void> future = new VertxCompletableFuture<>(Objects.requireNonNull(context));
  context.executeBlocking(
      fut -> {
        try {
          runnable.run();
          future.complete(null);
        } catch (Throwable e) {
          future.completeExceptionally(e);
        }
      },
      null
  );
  return future;
}
 

import io.vertx.core.Context; //导入方法依赖的package包/类
/**
 * Returns a new CompletableFuture that is asynchronously completed by a task running in the worker thread pool of
 * Vert.x
 * <p>
 * This method is different from {@link CompletableFuture#supplyAsync(Supplier)} as it does not use a fork join
 * executor, but the worker thread pool.
 *
 * @param context  the context in which the supplier is executed.
 * @param supplier a function returning the value to be used to complete the returned CompletableFuture
 * @param <T>      the function's return type
 * @return the new CompletableFuture
 */
public static <T> VertxCompletableFuture<T> supplyBlockingAsync(Context context, Supplier<T> supplier) {
  Objects.requireNonNull(supplier);
  VertxCompletableFuture<T> future = new VertxCompletableFuture<>(context);
  context.<T>executeBlocking(
      fut -> {
        try {
          fut.complete(supplier.get());
        } catch (Throwable e) {
          fut.fail(e);
        }
      },
      ar -> {
        if (ar.failed()) {
          future.completeExceptionally(ar.cause());
        } else {
          future.complete(ar.result());
        }
      }
  );
  return future;
}
 

import io.vertx.core.Context; //导入方法依赖的package包/类
/**
 * Returns a new CompletableFuture that is asynchronously completed by a
 * action running in the worker thread pool of Vert.x
 * <p>
 * This method is different from {@link CompletableFuture#runAsync(Runnable)}
 * as it does not use a fork join executor, but the worker thread pool.
 *
 * @param context  the Vert.x context
 * @param runnable the action, when its execution completes, it completes the
 *                 returned CompletableFuture. If the execution throws an exception,
 *                 the returned CompletableFuture is completed exceptionally.
 * @return the new CompletableFuture
 */
public static VertxCompletableFuture<Void> runBlockingAsync(Context context, Runnable runnable) {
  Objects.requireNonNull(runnable);
  VertxCompletableFuture<Void> future = new VertxCompletableFuture<>(Objects.requireNonNull(context));
  context.executeBlocking(fut -> {
    try {
      runnable.run();
      future.complete(null);
    } catch (Throwable e) {
      future.completeExceptionally(e);
    }
  }, null);
  return future;
}