Anonymous CompletableFuture threads with burstable pods

public CompletableFuture<Empty> saveOrUpdateAsync(String a, String b) {
    return tryFindAsync(userId, clientId)
            .thenApply(t -> ...)
            .thenComposeAsync(
                    t -> manager.crud() (1)
                                .insert(t) (1)
                                .withLwtResultListener(error -> ...)) (1)
                                .executeAsync()); (1)
}

public <U> CompletableFuture<U> thenComposeAsync(
    Function<? super T, ? extends CompletionStage<U>> fn) {
    return uniComposeStage(defaultExecutor(), fn); (1)
}

/**
 * Returns the default Executor used for async methods that do not
 * specify an Executor. This class uses the {@link
 * ForkJoinPool#commonPool()} if it supports more than one (1)
 * parallel thread, or else an Executor using one thread per async
 * task.  This method may be overridden in subclasses to return
 * an Executor that provides at least one independent thread.
 *
 * @return the executor
 * @since 9
 */
public Executor defaultExecutor() {
    return ASYNC_POOL;
}

private static final boolean USE_COMMON_POOL =
    (ForkJoinPool.getCommonPoolParallelism() > 1);

/**
 * Default executor -- ForkJoinPool.commonPool() unless it cannot
 * support parallelism.
 */
private static final Executor ASYNC_POOL = USE_COMMON_POOL ?
    ForkJoinPool.commonPool() : new ThreadPerTaskExecutor();

/** Fallback if ForkJoinPool.commonPool() cannot support parallelism */
static final class ThreadPerTaskExecutor implements Executor {
    public void execute(Runnable r) { new Thread(r).start(); }
}

$ env -u JDK_JAVA_OPTIONS jshell -s - \
    <<<'System.out.printf("fjp-parallelism: %d%n", java.util.concurrent.ForkJoinPool.getCommonPoolParallelism())'
fjp-parallelism: 1

resources:
  limits:
    memory: "5.5Gi"
  requests:
    cpu: 2 (1)
    memory: "5.5Gi"

$ cat /sys/fs/cgroup/cpu/cpu.shares
2048

$ env -u JDK_JAVA_OPTIONS jshell -s - \
    <<<'System.out.printf("procs: %d%n", Runtime.getRuntime().availableProcessors())'
procs: 2

/**
 * Returns the targeted parallelism level of the common pool.
 *
 * @return the targeted parallelism level of the common pool
 * @since 1.8
 */
public static int getCommonPoolParallelism() {
    return COMMON_PARALLELISM;
}

static {
    // ...
    common = AccessController.doPrivileged(new PrivilegedAction<>() {
        public ForkJoinPool run() {
            return new ForkJoinPool((byte)0); }});

    COMMON_PARALLELISM = Math.max(common.mode & SMASK, 1);
}

/**
 * Constructor for common pool using parameters possibly
 * overridden by system properties
 */
private ForkJoinPool(byte forCommonPoolOnly) {
    int parallelism = -1;
    // ...
    try {  // ignore exceptions in accessing/parsing properties
        String pp = System.getProperty
            ("java.util.concurrent.ForkJoinPool.common.parallelism");
        if (pp != null)
            parallelism = Integer.parseInt(pp);
        // ...
    } catch (Exception ignore) {
    }

    // ...
    if (parallelism < 0 && // default 1 less than #cores
        (parallelism = Runtime.getRuntime().availableProcessors() - 1) <= 0) (1)
        parallelism = 1; (1)
    if (parallelism > MAX_CAP)
        parallelism = MAX_CAP;

    // ...

    this.mode = parallelism;
    // ...
}

$ env JDK_JAVA_OPTIONS="-Djava.util.concurrent.ForkJoinPool.common.parallelism=3" \
    jshell -s - \
    <<<'System.out.printf("fjp-parallelism: %d%n", java.util.concurrent.ForkJoinPool.getCommonPoolParallelism())'
fjp-parallelism: 3