Forem: 24adithya

💡Java Virtual Threads Explained: Continuations, Carrier Threads, and Scalable Concurrency

24adithya — Sun, 29 Jun 2025 13:06:30 +0000

📌 Introduction

Java has long been a reliable language for concurrent programming. But for I/O-heavy, high-concurrency systems, traditional OS thread-based models introduced scaling limits.
Virtual Threads (from Java 21’s Project Loom) revolutionize this by allowing 10,000+ lightweight concurrent threads — without the headaches of thread pool sizing or async callbacks.

In this post, I’ll explain what Virtual Threads are, how they work internally with continuations, and where you should — and shouldn’t — use them. I’ll also show you how to write and benchmark them with real code.

📍 What Are Virtual Threads?

A virtual thread is a lightweight user-space thread managed by the JVM. When a virtual thread performs a blocking operation (like a file read or HTTP call), the JVM parks the thread and frees up the underlying OS thread to handle other work.

When the blocking operation completes, the virtual thread is unparked and resumed by any available OS thread.

📍 How To Spawn Virtual Threads

Creating virtual threads is as easy as using Thread.ofVirtual():

ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
executor.submit(() -> System.out.println("Task in virtual thread"));
executor.shutdown();

Or use an ExecutorService:

ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
executor.submit(() -> System.out.println("Task in virtual thread"));
executor.shutdown();

📍 Carrier Threads: The Backbone Behind Virtual Threads

While virtual threads themselves are lightweight and managed by the JVM, they still need to run on actual OS threads when active. These are called carrier threads.

When a virtual thread performs work:

It’s picked up by a carrier thread (native OS thread) from a small internal ForkJoinPool.
If the virtual thread blocks on I/O:
The JVM parks the virtual thread (saves its continuation).
The carrier thread is freed up for other work.
When the I/O operation completes:
The virtual thread is unparked.
Scheduled on any available carrier thread to resume execution. Key point: A virtual thread is not bound to a specific carrier thread. It can run on any available carrier thread when ready — enabling extreme concurrency with minimal OS thread usage.

📌 Where Do Carrier Threads Come From?

By default:

The JVM uses a ForkJoinPool internally to manage these carrier threads.

Its size is typically equal to Runtime.getRuntime().availableProcessors() but can be configured via:

-Djdk.virtualThreadScheduler.parallelism=16

📌 Benchmark: OS Threads vs Virtual Threads

Let’s see how they perform for an I/O-heavy task like making multiple HTTP requests.

Benchmark Code:

import java.net.URI;
import java.net.http.;
import java.util.concurrent.;
import java.util.stream.IntStream;

public class ThreadBenchmark {

    static final int TASK_COUNT = 1000;

    public static void main(String[] args) throws Exception {
        System.out.println("Benchmarking with OS Threads...");
        benchmarkWithExecutor(Executors.newFixedThreadPool(100));  

        System.out.println("\nBenchmarking with Virtual Threads...");
        benchmarkWithExecutor(Executors.newVirtualThreadPerTaskExecutor());
    }

    private static void benchmarkWithExecutor(ExecutorService executor) throws Exception {
        var client = HttpClient.newHttpClient();
        var start = System.currentTimeMillis();

        var futures = IntStream.range(0, TASK_COUNT)
            .mapToObj(i -> executor.submit(() -> {
                try {
                    var request = HttpRequest.newBuilder(URI.create("https://httpbin.org/get")).build();
                    var response = client.send(request, HttpResponse.BodyHandlers.ofString());
                    System.out.println(Thread.currentThread() + " got response " + i);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }))
            .toList();

        for (var future : futures) {
            future.get();
        }

        var end = System.currentTimeMillis();
        System.out.println("Time taken: " + (end - start) + " ms");

        executor.shutdown();
    }
}

⚡ Try changing TASK_COUNT to 10,000 — you’ll notice virtual threads handling it gracefully, while OS thread pools may choke or exhaust memory.

📍 How Virtual Threads Work (Continuations Behind the Scenes)

When a virtual thread blocks:

The JVM captures its continuation — the current call stack, local variables, and program counter.

The virtual thread is parked (suspended)

The underlying OS thread is released for other tasks

Once the blocking operation completes, the virtual thread is unparked and resumed — potentially on a different OS thread.

This is made possible by jdk.internal.vm.Continuation, which acts like a bookmark in the thread’s execution flow.

📍 Similarity to Other Languages

Language	Mechanism
Go	Goroutines
Kotlin	Coroutines
Python	AsyncIO + async/await
JavaScript	Async/await + microtask queue

Java 21+ finally joins this club with a clean, native solution.

📍 When to Use Virtual Threads ✅

HTTP servers
Database access
Microservices
File and network I/O
High concurrency workloads with blocking calls

📍 When Not to Use ❌

CPU-bound computations
(Use a FixedThreadPool sized to available cores)
Native blocking code via JNI — still blocks OS thread
Not a replacement for parallel processing

📍 Recap Table

Feature	OS Threads	Virtual Threads
Backed by	OS kernel thread	Lightweight, JVM-managed
Blocking call	Ties up OS thread	Parks virtual thread
CPU-bound parallelism	Excellent	Same as OS threads
I/O concurrency	Limited	10k+ scalable threads
Scheduling	OS kernel	JVM continuation scheduling

📌 Final Thought

Virtual Threads make asynchronous-like scalability achievable with simple, blocking code in Java. Project Loom modernizes concurrency without losing Java’s type safety or predictability.

If you build server-side or networked Java apps — this is the future.

💬 Would love to hear your thoughts — drop a comment or share your experience with Virtual Threads!

Configuring ESLint to use with Prettier and HTML-ESlint parser

24adithya — Sun, 31 Dec 2023 05:01:51 +0000

There are many posts explaining configuring ESLint and Prettier in combination or separately. To circumvent the complexity surrounding this complexity few have created a node module that you download and your ESLint is configured to be used with Prettier automatically.

To keep this post short, I will dive into configuring ESLint to be used with Prettier rules.

If you want to read about ESLint and Prettier, I will post the links to the end of this article.

ESLint Configuration with Prettier Integration

This guide provides step-by-step instructions on setting up ESLint with Prettier integration for consistent code linting and formatting in your JavaScript/TypeScript projects.

Prerequisites

Make sure you have Node.js and npm installed on your machine. If not, you can download and install them from https://nodejs.org/.

The node version we will be using for this configuration is 20.10.0

Step 1: Initialize Your Project

npm init -y

Step 2: Install ESLint

npx eslint --init

You will be asked a variety of questions as follows:

Need to install the following packages:

@eslint/create-config@0.4.6

Ok to proceed? (y) y

√ How would you like to use ESLint? · style

√ What type of modules does your project use? · esm

√ Which framework does your project use? · react

√ Does your project use TypeScript? · No / Yes

√ Where does your code run? · browser, node

√ How would you like to define a style for your project? · guide

√ Which style guide do you want to follow? · standard

√ What format do you want your config file to be in? · JSON

Checking peerDependencies of eslint-config-standard@latest

The config that you've selected requires the following dependencies:

eslint-plugin-react@latest eslint-config-standard@latest eslint@^8.0.1 eslint-plugin-import@^2.25.2 eslint-plugin-n@^15.0.0 || ^16.0.0 eslint-plugin-promise@^6.0.0

√ Would you like to install them now? · No / Yes

√ Which package manager do you want to use? · npm

Installing eslint-plugin-react@latest, eslint-config-standard@latest, eslint@^8.0.1, eslint-plugin-import@^2.25.2, eslint-plugin-n@^15.0.0 || ^16.0.0 , eslint-plugin-promise@^6.0.0

Step 3: Generated `.eslintrc.json`

{
    "env": {
        "browser": true,
        "node": true,
        "es2021": true
    },
    "extends": [
        "standard",
    ],
    "parserOptions": {
        "ecmaVersion": "latest",
        "sourceType": "module"
    },
    "plugins": [
        "react"
    ],
}

Step 4: Install Prettier

Install Prettier module as follows:

npm install prettier --save-dev

Step 5: Install dependencies for ESlint to work with Prettier

npx install-peerdeps eslint-config-prettier --dev
npx install-peerdeps eslint-plugin-prettier --dev

Step 6: Install ESLint extension for VS Code

Step 7: Update `.eslintrc.json` with Prettier rules

{
    "extends": [
        "eslint:recommended",
        "plugin:prettier/recommended" //Extend Prettier settings
    ],
    "plugins": [
        "react",
        "prettier", //Add prettier plugin
    ],
    "rules": {
        "prettier/prettier": [ //Add following rules as per your requirement
            "error",
            {
                "singleQuote": true,
                "endOfLine": "auto",
                "tabWidth": 2,
                "trailingComma": "none"
            }
        ],
        "no-console": "off", //switch to warn for production
        "no-unused-vars": "warn"
    },
    "globals": { //Optional in case you don't have console statements
        "console": true
    },  
}

Step 8: VS Code Settings

Update your VS Code settings settings.json to enable ESLint and Prettier integration.

{
  "editor.formatOnSave": false,
  // tell the ESLint plugin to run on save
  "editor.codeActionsOnSave": {
    "source.fixAll.eslint": "explicit"
  },
  "eslint.format.enable": true,
  "files.eol": "\n",
  // turn it off for JS and JSX, we will do this via eslint
  "[javascript][javascriptreact][typescript][typescriptreact]": {
    "editor.formatOnSave": false
  }
}

Restart VS Code for the changes to take place

Step 9: Create NPM Scripts

In your package.json file, add NPM scripts for linting and fixing:

"scripts": {
  "lint": "eslint .",
  "lint:fix": "eslint . --fix"
}

Step 10: Run ESLint

npm run lint

Step 11: Auto-Fix ESLint Issues

npm run lint:fix

or you can run

npx eslint . --fix

These steps will configure ESLint with Prettier in your project, ensuring consistent code formatting and style enforcement. Customize the configurations based on your project's specific needs.

Step 12: ESLint settings for HTML files

Install html-eslint plugin

npm install --save-dev eslint @html-eslint/parser @html-eslint/eslint-plugin

Step 13: Update `.eslintrc.json` file

{
    "plugins": [
        "react",
        "prettier",
        "@html-eslint" //Added HTML lint plugin
    ],
    "overrides": [
        {
            "files": [
                "*.html"
            ],
            "parser": "@html-eslint/parser", //Added HTML parser 
            "extends": [
                "plugin:@html-eslint/recommended" //Extend HTML parser
            ]
        }
    ]
}

Step 14: Update VS Code settings.json

Add the following:

"eslint.validate": [
    "javascript", // ...
    "html" // Add "html" to enable linting `.html` files.
]

Restart VS Code again for the changes to take place

Full `.eslintrc.json`

{
    "env": {
        "browser": true,
        "node": true,
        "es2021": true
    },
    "extends": [
        "eslint:recommended",
        "plugin:prettier/recommended"
    ],
    "parserOptions": {
        "ecmaVersion": "latest",
        "sourceType": "module"
    },
    "plugins": [
        "react",
        "prettier",
        "@html-eslint"
    ],
    "rules": {
        "prettier/prettier": [
            "error",
            {
                "singleQuote": true,
                "endOfLine": "auto",
                "tabWidth": 2,
                "trailingComma": "none"
            }
        ],
        "no-console": "off",
        "no-unused-vars": "warn"
    },
    "globals": {
        "console": true
    },
    "overrides": [
        {
            "files": [
                "*.html"
            ],
            "parser": "@html-eslint/parser",
            "extends": [
                "plugin:@html-eslint/recommended"
            ]
        }
    ]
}

References and Credits

HTML ESLint parser
ESLint
Prettier
WESBOS ESLint Config

If you have any questions, do post in the comments and I will try my best to answer them