Java Virtual Threads

Su Suriya Ravichandran Updated 18 Nov 2026
13 min read ·Lesson 200 of 306

Java virtual threads are lightweight threads managed by the JVM instead of the operating system. You can create millions of them, one per task, so a server can handle a huge number of concurrent requests while you keep writing simple, blocking, step-by-step code.

Virtual threads became a standard feature in Java 21 (JEP 444). This lesson shows how to create them, how they work under the hood, how they compare to platform threads, and how to use them correctly in real applications.


Platform Threads vs Virtual Threads

Every thread you created in Java Threads and the lessons after it was a platform thread: a thin wrapper around an operating-system thread. OS threads are expensive, so a program can afford only a few thousand of them. A virtual thread is just a Java object; the JVM runs it on a small pool of platform threads called carrier threads.

Platform threadVirtual thread
Managed byOperating systemJVM
MemoryAbout 1 MB stack reserved up frontA few hundred bytes, grows as needed
Practical limitThousandsMillions
Creation costHigh (system call)Very low (an object allocation)
What happens when it blocksThe OS thread blocks tooThe JVM unmounts it, and the carrier runs another virtual thread
Daemon?ConfigurableAlways daemon
Best forCPU-heavy work, long-running background threadsTasks that mostly wait: HTTP, database, file I/O, sleeps

Note: Virtual threads do not make code run faster. They let you run more tasks at the same time when those tasks spend most of their time waiting.


How to Create Virtual Threads in Java

Java offers several ways to start a virtual thread. They all produce ordinary java.lang.Thread objects, so join(), interrupt() and getName() work as usual.

WayExample
Start one immediatelyThread.startVirtualThread(task)
Builder, start immediatelyThread.ofVirtual().name("worker").start(task)
Builder, start laterThread.ofVirtual().unstarted(task)
Numbered namesThread.ofVirtual().name("worker-", 1)
One per task in an executorExecutors.newVirtualThreadPerTaskExecutor()
public class CreateVirtualThreads {
    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> {
            Thread current = Thread.currentThread();
            System.out.println("name='" + current.getName() + "' virtual=" + current.isVirtual()
                    + " daemon=" + current.isDaemon());
        };

        // 1. The quickest way
        Thread quick = Thread.startVirtualThread(task);
        quick.join();

        // 2. A builder with numbered names: worker-1, worker-2, ...
        Thread.Builder builder = Thread.ofVirtual().name("worker-", 1);
        Thread first = builder.start(task);
        first.join();
        Thread second = builder.start(task);
        second.join();

        // 3. Create now, start later
        Thread later = Thread.ofVirtual().name("report-job").unstarted(task);
        System.out.println("before start: state=" + later.getState());
        later.start();
        later.join();

        // For comparison: a platform thread
        Thread platform = Thread.ofPlatform().name("platform-1").start(task);
        platform.join();
    }
}

Output:

name='' virtual=true daemon=true
name='worker-1' virtual=true daemon=true
name='worker-2' virtual=true daemon=true
before start: state=NEW
name='report-job' virtual=true daemon=true
name='platform-1' virtual=false daemon=false

How it works:

  • Thread.startVirtualThread() creates and starts an unnamed virtual thread; its name is an empty string.
  • Thread.ofVirtual() returns a Thread.Builder. name("worker-", 1) makes the builder number each thread it creates.
  • unstarted() creates the thread in the NEW state; nothing runs until start().
  • Virtual threads are always daemon threads, so they never keep the JVM alive on their own. Remember to join() them or close their executor.

Running Tasks with newVirtualThreadPerTaskExecutor

In real code you rarely create threads by hand. Executors.newVirtualThreadPerTaskExecutor() returns an ExecutorService that starts a new virtual thread for every task. It works with submit(), invokeAll() and Future like any other executor.

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class VirtualThreadExecutor {
    public static void main(String[] args) throws Exception {
        long start = System.currentTimeMillis();
        List<Future<Integer>> results = new ArrayList<>();

        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < 10_000; i++) {
                int taskNumber = i;
                results.add(executor.submit(() -> {
                    Thread.sleep(1000); // each task "waits on the network" for 1 second
                    return taskNumber;
                }));
            }

            long sum = 0;
            for (Future<Integer> result : results) {
                sum += result.get();
            }
            System.out.println("Tasks finished: " + results.size());
            System.out.println("Sum of task numbers: " + sum);
        }
        long elapsed = Math.round((System.currentTimeMillis() - start) / 100.0) * 100;
        System.out.println("Total time: about " + elapsed + " ms");
    }
}

Output from one run:

Tasks finished: 10000
Sum of task numbers: 49995000
Total time: about 1100 ms

How it works:

  • 10,000 tasks are submitted, and each gets its own virtual thread.
  • All of them sleep at the same time, so the whole batch takes only a little more than one second.
  • With a fixed pool of, say, 100 platform threads, the same work would take about 100 seconds, because only 100 tasks could wait at once.
  • The try-with-resources block closes the executor, which waits until every virtual thread has finished.

Virtual Threads vs a Platform Thread Pool

The next example runs the same 1,000 waiting tasks twice: on a fixed pool of 50 platform threads, and with one virtual thread per task.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class PlatformVsVirtual {
    static void runTasks(ExecutorService executor, int taskCount) {
        try (executor) {
            for (int i = 0; i < taskCount; i++) {
                executor.submit(() -> {
                    Thread.sleep(100); // a 100 ms database query
                    return null;
                });
            }
        } // waits for all tasks
    }

    static long measure(ExecutorService executor) {
        long start = System.currentTimeMillis();
        runTasks(executor, 1000);
        return Math.round((System.currentTimeMillis() - start) / 100.0) * 100;
    }

    public static void main(String[] args) {
        long platformMs = measure(Executors.newFixedThreadPool(50));
        long virtualMs = measure(Executors.newVirtualThreadPerTaskExecutor());

        System.out.println("50 platform threads : about " + platformMs + " ms");
        System.out.println("virtual threads     : about " + virtualMs + " ms");
    }
}

Output from one run:

50 platform threads : about 2000 ms
virtual threads     : about 100 ms

How it works:

  • The platform pool can run only 50 queries at once, so 1,000 queries need 20 rounds of 100 ms: about 2 seconds.
  • With virtual threads, all 1,000 queries wait at the same time, so the batch finishes in about 100 ms.
  • try (executor) is a Java 9+ form of try-with-resources that closes an existing variable.

How Virtual Threads Work: Mounting and Carrier Threads

The JVM has a scheduler (a ForkJoinPool with about one carrier thread per CPU core). It mounts a virtual thread on a free carrier to run it. When the virtual thread blocks, for example in sleep(), a socket read or BlockingQueue.take(), the JVM unmounts it, saves its stack in memory, and lets the carrier run another virtual thread. When the wait is over, the virtual thread is mounted again, possibly on a different carrier.

import java.util.ArrayList;
import java.util.List;

public class CarrierThreads {
    public static void main(String[] args) throws InterruptedException {
        List<Thread> threads = new ArrayList<>();

        for (int i = 1; i <= 3; i++) {
            threads.add(Thread.ofVirtual().name("vt-" + i).start(() -> {
                System.out.println("before sleep: " + Thread.currentThread());
                try {
                    Thread.sleep(100); // unmounts from the carrier
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                System.out.println("after sleep : " + Thread.currentThread());
            }));
        }
        for (Thread thread : threads) {
            thread.join();
        }
    }
}

Output from one run (IDs, order and carrier numbers vary):

before sleep: VirtualThread[#22,vt-1]/runnable@ForkJoinPool-1-worker-1
before sleep: VirtualThread[#24,vt-2]/runnable@ForkJoinPool-1-worker-2
before sleep: VirtualThread[#25,vt-3]/runnable@ForkJoinPool-1-worker-1
after sleep : VirtualThread[#24,vt-2]/runnable@ForkJoinPool-1-worker-1
after sleep : VirtualThread[#22,vt-1]/runnable@ForkJoinPool-1-worker-2
after sleep : VirtualThread[#25,vt-3]/runnable@ForkJoinPool-1-worker-2

How it works:

  • A virtual thread's toString() shows its ID, its name, and the carrier it is mounted on after the @.
  • vt-1 starts on worker-1 but continues on worker-2 after sleeping: it was unmounted during the sleep and remounted on whichever carrier was free.
  • Three virtual threads share only two carriers here. With thousands of virtual threads, the same small set of carriers serves them all.

Note: Code inside a virtual thread cannot tell which carrier it runs on, and should not care. Treat the carrier as an implementation detail.


Limiting Concurrency with a Semaphore

Virtual threads are cheap, so do not pool them. A pool exists to limit how many expensive threads you create; virtual threads do not need that. But sometimes you must limit how many tasks use a scarce resource, such as a database that accepts only 3 connections. Use a Semaphore for that, not a smaller pool.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;

public class SemaphoreWithVirtualThreads {
    private static final Semaphore dbPermits = new Semaphore(3); // max 3 queries at once
    private static final AtomicInteger running = new AtomicInteger();
    private static final AtomicInteger maxRunning = new AtomicInteger();

    static String queryDatabase(int id) throws InterruptedException {
        dbPermits.acquire(); // waits (cheaply) if 3 queries are already running
        try {
            int now = running.incrementAndGet();
            maxRunning.accumulateAndGet(now, Math::max);
            Thread.sleep(100); // the query itself
            return "row-" + id;
        } finally {
            running.decrementAndGet();
            dbPermits.release();
        }
    }

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int id = 1; id <= 12; id++) {
                int rowId = id;
                executor.submit(() -> queryDatabase(rowId));
            }
        }
        System.out.println("Max queries at the same time: " + maxRunning.get());
        System.out.println("Total time: about "
                + Math.round((System.currentTimeMillis() - start) / 100.0) * 100 + " ms");
    }
}

Output:

Max queries at the same time: 3
Total time: about 400 ms

How it works:

  • All 12 tasks get their own virtual thread right away.
  • acquire() lets only three tasks into the query section at a time; the others wait. A waiting virtual thread is unmounted, so it costs almost nothing.
  • 12 queries in groups of 3, each taking 100 ms, finish in about 400 ms. The AtomicInteger counters, explained in Java Atomic Classes, confirm that no more than 3 ran at once.

When to Use Java Virtual Threads

Task typeVirtual threads help?Why
Web server handling requestsYesEach request mostly waits for the database or other services
Calling many REST APIs at onceYesThousands of HTTP calls can wait in parallel
Reading many files or socketsYesBlocking I/O unmounts the virtual thread
Image processing, number crunchingNoThe work keeps the CPU busy; use a pool sized to the core count or parallel streams
A few long-running background threadsNo real gainPlatform threads are fine

ThreadLocal and ScopedValue

Because there can be millions of virtual threads, storing large objects in a ThreadLocal can use a lot of memory, and caching expensive objects per thread no longer works, since each task has a brand-new thread. For passing request data such as the current user down the call chain, Java 25 finalised ScopedValue, a lighter, immutable alternative.

public class ScopedValueDemo {
    private static final ScopedValue<String> CURRENT_USER = ScopedValue.newInstance();

    static void loadOrders() {
        // Any method called inside the scope can read the value
        System.out.println(Thread.currentThread().getName() + " loads orders for " + CURRENT_USER.get());
    }

    public static void main(String[] args) throws InterruptedException {
        Thread request = Thread.ofVirtual().name("request-1").start(() ->
                ScopedValue.where(CURRENT_USER, "asha@gocourse.in").run(ScopedValueDemo::loadOrders));
        request.join();
        System.out.println("Bound outside the scope? " + CURRENT_USER.isBound());
    }
}

Output (Java 25 or later):

request-1 loads orders for asha@gocourse.in
Bound outside the scope? false

How it works:

  • ScopedValue.where(key, value).run(task) binds the value only while task runs.
  • loadOrders() reads it with get() without receiving it as a parameter.
  • Outside the run() call the value is no longer bound, so nothing leaks into later tasks.

Pinning

A virtual thread is pinned to its carrier when it cannot be unmounted while blocking, which wastes the carrier. Up to Java 23, blocking inside a synchronized block caused pinning, so the advice was to use ReentrantLock instead. Since Java 24 (JEP 491), synchronized no longer pins. Calls into native code can still pin, and the JDK Flight Recorder event jdk.VirtualThreadPinned reports where it happens.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SynchronizedOnVirtualThreads {
    private static final Object lock = new Object();
    private static int bookedSeats = 0;

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < 1_000; i++) {
                executor.submit(() -> {
                    Thread.sleep(50);          // waiting outside the lock: fully concurrent
                    synchronized (lock) {      // short critical section
                        bookedSeats++;
                    }
                    return null;
                });
            }
        }
        System.out.println("Booked seats: " + bookedSeats);
        System.out.println("Total time  : about "
                + Math.round((System.currentTimeMillis() - start) / 100.0) * 100 + " ms");
    }
}

Output from one run:

Booked seats: 1000
Total time  : about 100 ms

How it works:

  • 1,000 virtual threads sleep at the same time and then update a shared counter inside a short synchronized block.
  • The block keeps the counter correct, as in Java synchronization.
  • Keeping slow waits outside the lock lets all the threads overlap, so the run takes about the time of one sleep.

Real-World Example: An Order Processing Service

An online shop processes 1,000 orders. For each order it loads the customer and checks inventory at the same time, then charges the payment gateway, which allows at most 50 parallel requests. Each order runs in its own virtual thread and is written as plain blocking code.

import java.util.ArrayList;
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.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.LongAdder;

public class OrderProcessingService {
    record OrderResult(int orderId, boolean paid, int amount) { }

    private final Semaphore gatewayPermits = new Semaphore(50); // gateway limit
    private final AtomicInteger inGateway = new AtomicInteger();
    private final AtomicInteger peakGateway = new AtomicInteger();
    private final LongAdder declined = new LongAdder();

    // --- simulated blocking calls ---
    String loadCustomer(int orderId) throws InterruptedException {
        Thread.sleep(50);
        return "customer-" + (orderId % 300);
    }

    boolean inStock(int orderId) throws InterruptedException {
        Thread.sleep(80);
        return true;
    }

    boolean charge(String customer, int amount, int orderId) throws InterruptedException {
        gatewayPermits.acquire();
        try {
            peakGateway.accumulateAndGet(inGateway.incrementAndGet(), Math::max);
            Thread.sleep(100);
            return orderId % 97 != 0; // some cards are declined
        } finally {
            inGateway.decrementAndGet();
            gatewayPermits.release();
        }
    }

    OrderResult process(int orderId, ExecutorService executor) throws Exception {
        int amount = 199 + (orderId % 5) * 100;

        // Fan out: two lookups in parallel, each in its own virtual thread
        Future<String> customer = executor.submit(() -> loadCustomer(orderId));
        Future<Boolean> stock = executor.submit(() -> inStock(orderId));

        if (!stock.get()) {
            return new OrderResult(orderId, false, 0);
        }
        boolean paid = charge(customer.get(), amount, orderId);
        if (!paid) {
            declined.increment();
        }
        return new OrderResult(orderId, paid, paid ? amount : 0);
    }

    public static void main(String[] args) throws InterruptedException {
        OrderProcessingService service = new OrderProcessingService();
        long start = System.currentTimeMillis();
        List<Future<OrderResult>> results = new ArrayList<>();

        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int orderId = 1; orderId <= 1_000; orderId++) {
                int id = orderId;
                results.add(executor.submit(() -> service.process(id, executor)));
            }

            int paidOrders = 0;
            long revenue = 0;
            for (Future<OrderResult> future : results) {
                try {
                    OrderResult result = future.get();
                    if (result.paid()) {
                        paidOrders++;
                        revenue += result.amount();
                    }
                } catch (ExecutionException e) {
                    System.out.println("Order failed: " + e.getCause());
                }
            }

            long elapsed = Math.round((System.currentTimeMillis() - start) / 100.0) * 100;
            System.out.println("Orders processed     : " + results.size());
            System.out.println("Paid orders          : " + paidOrders);
            System.out.println("Declined payments    : " + service.declined.sum());
            System.out.println("Revenue              : Rs. " + revenue);
            System.out.println("Peak gateway calls   : " + service.peakGateway.get());
            System.out.println("Total time           : about " + elapsed + " ms");
        }
    }
}

Output from one run:

Orders processed     : 1000
Paid orders          : 990
Declined payments    : 10
Revenue              : Rs. 395010
Peak gateway calls   : 50
Total time           : about 2100 ms

How it works:

  1. One virtual thread per order. The main loop submits 1,000 tasks to a virtual-thread-per-task executor. Each process() call is ordinary blocking code with no callbacks.
  2. Fan-out inside a task. Each order submits loadCustomer() and inStock() as two more virtual threads, so the 50 ms and 80 ms lookups overlap. In total about 3,000 virtual threads exist, which is no problem.
  3. Blocking is cheap. stock.get(), customer.get() and Thread.sleep() all block, but every blocked virtual thread is unmounted, so a handful of carrier threads serve all of them.
  4. Respecting a limit. The Semaphore lets only 50 orders talk to the payment gateway at once, which the peak counter confirms. 1,000 charges of 100 ms in groups of 50 take about 2 seconds, plus 80 ms for the lookups.
  5. Results. Order IDs divisible by 97 are declined (10 orders), and the revenue of the other 990 orders adds up to Rs. 395,010.
  6. Compared to sequential code. Processing the orders one after another would take about 1,000 × 230 ms ≈ 230 seconds. Virtual threads cut that to about 2 seconds without changing the style of the code.

For running tasks and collecting their results, see Java Callable Interface, and for non-blocking pipelines that can also use a virtual-thread executor, see Java CompletableFuture.

0 Comments

Reviewed before they appear

No comments yet.

Java
Java Introduction Java Features Java Syntax Java Comments Java Statements Java Output Java Variables Java Data Types Java Type Casting Java Operators Java Strings Java Numbers Java Math Java Booleans Java User Input Java Conditions Java If Else Java Switch Java While Loop Java For Loop Java Break Java Continue Java Arrays Java Methods Java Parameters Java Return Values Java Scope Java Recursion Install Java Install JDK Java IDEs Java JDK Java JRE Java JVM Java Compiler Java File Compile Java Run Java JShell Basics Java Packages Java OOP Java Classes Java Objects Class Methods Constructors Constructor Overload this Keyword static Keyword final Keyword Encapsulation Inheritance Polymorphism Abstraction Access Modifiers super Keyword Method Overload Method Override Instanceof Operator Nested Classes Inner Classes Anonymous Classes Enums Records Array Basics Array Length Loop Arrays Multidimensional Arrays Array Copy Array Sorting Array Search ArrayList LinkedList HashSet TreeSet HashMap TreeMap Queue Interface Deque Interface Stack Class Iterator List Interface Set Interface Map Interface Collections Class Comparable Comparator Generics Basics Generic Classes Generic Methods Wildcards String Basics String Length String Methods String Concatenation String Compare String Search String Replace String Split String Format StringBuilder StringBuffer Text Blocks Regular Expressions Number Types Integer Class Float Class Double Class BigInteger BigDecimal Math Class Random Numbers Number Format Date Basics LocalDate LocalTime LocalDateTime ZonedDateTime Date Formatting Date Parsing Period Class Duration Class Java Instant Class Java Exception Basics Java try...catch Java Multiple Catch Blocks Java finally Block Java throw Keyword Java throws Keyword Java Checked Exceptions Java Unchecked Exceptions Java Custom Exceptions Java try-with-resources Java Exception Chaining Java File Basics Java Create Files Java Read Files Java Write Files Java Delete Files Java File Paths Java File Class Java BufferedReader Java BufferedWriter Java FileInputStream Java FileOutputStream Java Object Streams Java Directory Handling Java NIO Basics Java Files API Java Input Java Scanner Class Java Console Input Java PrintStream Java InputStream Java OutputStream Java Reader Class Java Writer Class Java Buffered Streams Java Data Streams Java Generics Introduction Java Generic Types Java Generic Methods Java Bounded Types Java Wildcards Java Type Erasure Java Generic Interfaces Java Generic Collections Java Lambda Basics Java Lambda Syntax Java Functional Interfaces Java Method References Java Stream API Java Stream Creation Java Stream Filter Java Stream Map Java Stream Reduce Java Stream Sort Java Stream Collect Java Collectors Class Java Optional Class Java Parallel Streams Java Threads: Thread Basics Create a Thread in Java Java Thread Class Java Runnable Interface Java Thread States Java Thread Sleep Java Thread Join Java Thread Priority Java Synchronization Java Thread Safety Java Race Conditions Java Deadlocks Java Executor Service Java Thread Pools Java Callable Interface Java Future Interface Java CompletableFuture Java Concurrent Collections Java Atomic Classes Java Virtual Threads Java Networking Basics Java URL Class Java URI Class Java HttpClient Java HTTP Requests Java HTTP Responses Java Socket Basics Java ServerSocket Java DatagramSocket Java WebSocket Basics Java JDBC Basics Java JDBC Setup Java Database Connection Java JDBC Connection Interface Java JDBC Statement Java PreparedStatement Java ResultSet Java JDBC CRUD Operations Java JDBC Transactions Java JDBC Batch Update Java Connection Pooling with HikariCP Java JPA Basics: Entities, EntityManager and JPQL Java Hibernate Basics: SessionFactory, Session and HQL Package in Java: Basics Explained with Examples Create Package in Java: Step-by-Step Guide with Examples Import Package in Java: The import Statement Explained Access Control in Java: Packages, Classes and Members JAR File in Java: Create, Run and Inspect JAR Files Java Modules: Introduction to the Java Module System module-info in Java: Every Module Directive Explained Java Module Path: How --module-path Finds Your Modules Java Classpath: How -cp and CLASSPATH Find Your Classes Java Annotations: Basics of @ Metadata in Java Java Built-in Annotations: @Override, @Deprecated and More Java Custom Annotations: Create Your Own @interface Java Annotation Targets: @Target and ElementType Explained Java Reflection API: Inspect and Use Classes at Runtime Java Class Metadata: Names, Modifiers, Hierarchy and Generic Java Dynamic Objects: Create Objects Dynamically With Reflec Java Dynamic Proxy: Intercept Method Calls With Proxy and In Java Security Java Secure Coding Java Password Hashing Java Input Validation Java Cryptography Basics Java KeyStore Basics Java TLS Basics Java SecureRandom Java JUnit Basics Java JUnit Test Methods JUnit Assertions JUnit Test Fixtures JUnit Parameterized Tests Mockito in Java Java Mock Objects Java Integration Testing Java Code Coverage Maven in Java Create a Maven Project in Java Maven Dependencies Maven Plugins Gradle in Java Gradle Build Gradle Dependencies Build Executable JAR in Java Build WAR File in Java HTTP Basics in Java Java Servlet Basics Servlet Lifecycle in Java HttpServletRequest in Java HttpServletResponse in Java JSP in Java JSTL in JSP REST API in Java JSON in Java Java Web Application Spring Framework Basics Spring Boot Tutorial Spring MVC Spring Data JPA Spring Security Spring Boot REST API Jakarta EE Basics Java Deployment JAR Deployment Java WAR Deployment Run Java as a Service Docker Java: Dockerize a Java Application Java Environment Variables and Configuration Java Logging Basics Java Production Setup Java JVM Options Java JVM Monitoring Java Hello World App Java Calculator App Java Number Guess Game Java Student Manager Java Library System Java Bank App Java Todo App Java File Manager Java Quiz App Java REST API Project Java Chat Server Java Employee Manager Java E-commerce API
Ask about this post
AI Ask about this post

Ask questions about Java Virtual Threads and get answers drawn from it.

Signed-in readers only.