VirtualAwareExecutor.java

import java.util.List;
import java.util.Collection;
import java.util.concurrent.*;
import java.util.stream.Collectors;

public final class VirtualAwareExecutor implements ExecutorService {

    private final ExecutorService virtualExecutor = Executors.newVirtualThreadPerTaskExecutor();

    @Override
    public void execute(Runnable command) {
        if (Thread.currentThread().isVirtual()) {
            command.run();
        } else {
            virtualExecutor.execute(command);
        }
    }

    @Override
    public <T> Future<T> submit(Callable<T> task) {
        if (Thread.currentThread().isVirtual()) {
            try {
                T result = task.call();
                return CompletableFuture.completedFuture(result);
            } catch (Throwable t) {
                CompletableFuture<T> cf = new CompletableFuture<>();
                cf.completeExceptionally(t);
                return cf;
            }
        }
        return virtualExecutor.submit(task);
    }

    @Override
    public Future<?> submit(Runnable task) {
        return submit(Executors.callable(task, null));
    }

    @Override
    public <T> Future<T> submit(Runnable task, T result) {
        return submit(Executors.callable(task, result));
    }

    // lifecycle delegates

    @Override public void shutdown() { virtualExecutor.shutdown(); }
    @Override public List<Runnable> shutdownNow() { return virtualExecutor.shutdownNow(); }
    @Override public boolean isShutdown() { return virtualExecutor.isShutdown(); }
    @Override public boolean isTerminated() { return virtualExecutor.isTerminated(); }
    @Override public boolean awaitTermination(long t, TimeUnit u) throws InterruptedException {
        return virtualExecutor.awaitTermination(t, u);
    }

    // bulk ops (simple delegation)

    @Override
    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) {
        return tasks.stream().map(this::submit).collect(Collectors.toList());
    }

    @Override
    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long t, TimeUnit u) {
        return invokeAll(tasks);
    }

    @Override
    public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws ExecutionException, InterruptedException {
        return submit(tasks.iterator().next()).get();
    }

    @Override
    public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long t, TimeUnit u) throws ExecutionException, InterruptedException {
        return invokeAny(tasks);
    }
}