Virtual Threads with async/await in Java

VirtualFuture.java

package com.mustafakoroglu.gist.virtualfuture;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.function.Supplier;
import java.util.stream.StreamSupport;

public final class VirtualFuture<T> {

  private static final ExecutorService EXECUTOR = Executors.newThreadPerTaskExecutor(
    Thread.ofVirtual().name("vfuture-", 0).factory()
  );

  private final Future<T> future;

  private VirtualFuture(final Future<T> future) {
    this.future = future;
  }

  public static <T> VirtualFuture<T> async(final Supplier<T> supplier) {
    return new VirtualFuture<>(EXECUTOR.submit(supplier::get));
  }

  public static VirtualFuture<Void> async(final Runnable runnable) {
    return new VirtualFuture<>((Future<Void>) EXECUTOR.submit(runnable));
  }

  public static <T> T await(final VirtualFuture<T> virtualFuture) {
    try {
      return virtualFuture.future.get();
    } catch (final InterruptedException e) {
      Thread.currentThread().interrupt();
      throw new UncheckedExecutionException(e);
    } catch (final ExecutionException e) {
      throw new UncheckedExecutionException(e);
    }
  }

  @SafeVarargs
  public static <T> List<T> awaitAll(final VirtualFuture<T>... fs) {
    return Arrays.stream(fs).map(VirtualFuture::await).toList();
  }

  public static <T> List<T> awaitAll(final Iterable<VirtualFuture<T>> fs) {
    return StreamSupport.stream(fs.spliterator(), false).map(VirtualFuture::await).toList();
  }

  private static final class UncheckedExecutionException extends RuntimeException {

    public UncheckedExecutionException(final Throwable cause) {
      super(cause);
    }
  }
}