DEV Community: Bhagyashri Birajdar

Platform Thread vs Virtual Thread in JAVA

Bhagyashri Birajdar — Tue, 03 Feb 2026 18:07:24 +0000

For a long time, I was confident that I understood how concurrency worked in Java.

Create a thread.
Start it.
Join it.
After that, a thread pool handled the growing workload.

Simple… right?

Then I started reading about Virtual Threads in Java (Project Loom), and suddenly I realized — we’ve been living with limitations we just accepted as “normal”.

This post is my attempt to explain:

What Platform Threads are
What problems virtual threads solve
How they differ
And when it makes sense to use one over the other

not like documentation, but like how I actually understood it.

1. Platform Threads

In Java, the classic thread model is called a Platform Thread. These are traditional threads backed directly by the Operating System.

Every Java developer starts with this:

Thread thread = new Thread(() -> {
    doWork();
});
thread.start(); // Starts a new platform thread

It feels powerful at first. You’re doing real parallel work. Actual multitasking.

But then the cracks appear.

Creating too many threads? ❌ App slows down.
Thousands of requests? ❌ Thread pool exhausted.
Blocking I/O? ❌ Threads just sit there doing nothing.

Why...?

Because platform threads are directly mapped to OS threads.

That means:

One Java thread = one OS thread.
OS threads are expensive.
Each thread has a big stack and scheduling cost.

So instead of writing simple code, we started doing tricks:

Fixed-size thread pools.
Async APIs.
Reactive programming.
Complicated execution models.

Not because we wanted to — but because threads didn’t scale.

The Question That Couldn’t Be Ignored
If a thread is waiting for I/O, why is it still blocking an OS thread?

During I/O operations, a thread:

isn’t doing any computation.
isn’t using the CPU.
is simply waiting for an external operation to complete.

So why is it treated like a scarce system resource?
If the thread isn’t actively running, why should it continue holding an OS thread?

That question is exactly where Virtual Threads come in.

2. Virtual Threads — Lightweight & Scalable

Virtual threads are super-light, JVM-managed threads that let us handle millions of concurrent tasks without worrying about OS thread overhead.

Creating one is straightforward:

Thread thread = Thread.startVirtualThread(() -> {
    doWork();
});

That’s it.

Same programming model.
Same blocking style.
Totally different execution story.

Virtual threads are:

Created by the JVM
Not permanently attached to OS threads
Extremely cheap compared to platform threads

And that changes everything.

What Actually Happens?
Virtual threads run on top of platform threads, called carrier threads.

When a virtual thread:

is running -> it’s mounted on a carrier thread.
hits a blocking operation -> it gets parked.
is unblocked -> it resumes on any available carrier thread.

So instead of blocking an OS thread while waiting, the JVM simply moves on.

In simple terms:

Platform threads block the system.
Virtual threads block only themselves.

This solves the core scalability problem of platform threads.

Blocking I/O no longer wastes OS threads.
Thread pools stop being a hard limit.
Simple blocking code can scale to massive concurrency.

Virtual threads don’t remove blocking — they remove the cost of blocking.

That’s the breakthrough.

3. How They Differ?

This difference is easier to see in the diagram below - notice what happens during blocking.

4. When it makes sense to use one over the other?

Virtual threads are a great default for most modern applications — especially when the workload is I/O-heavy.

They make sense when:

Handling many concurrent requests
Waiting on databases, APIs, or file systems
Building web servers, APIs, or microservices
Wanting simple, blocking code that still scales

Platform threads still matter, though.

They make sense when:

The work is CPU-intensive
Threads need tight interaction with the OS
Thread pinning or native calls are involved

In practice, it comes down to this:

Use virtual threads for waiting.
Use platform threads for computing.

That rule alone covers most real-world decisions.

Final take

Virtual threads didn’t make Java faster.
They just stopped punishing us for blocking.

We can write simple code.
We can wait on I/O.
And the JVM handles the mess.

No thread pool anxiety.
No async gymnastics.
No PhD in callbacks.

Same Java.
Same threads (mostly).
Just way fewer headaches.

That’s it.
If this helped you even a little, hit ❤️, drop a comment, or share your thoughts below.

I N T E R F A C E (JAVA-8)

Bhagyashri Birajdar — Tue, 20 Feb 2024 07:34:30 +0000

I n t r o d u c t i o n

Java interfaces are a fundamental concept in the world of Java programming.We'll start by understanding what interfaces are? and then explore their syntax, usage and the various features of interfaces.
Additionally, we'll talk about the evolution of interfaces in Java. It will cover how interfaces have developed and improved over the years, starting from their basic form in the earlier versions of Java to the enhancements and changes introduced in Java 8.

Why Interfaces Were Introduced in Java?

Interfaces were introduced in Java to achieve :

abstraction
multiple inheritance
polymorphism
promoting modular, flexible, and reusable code.

I N T E R F A C E

In Java, an interface is a blueprint of a class and is a key mechanism for achieving abstraction, that can contain only constants, method signatures, default methods, static methods, and nested types. However, it cannot contain method implementations. Instead, classes that implement interfaces
must have to provide the method implementations.

Java Interface also represents the IS-A relationship.

The relationship between classes and interfaces

A class can extend another class similar to this an interface can extend another interface using extends keyword and a class can implement another interface using implements keyword but vice-versa is not allowed.

How to declare interface in java?

Use the interface keyword followed by the name of the interface.
Inside the interface, define method signatures. These are declarations of methods with the empty body.
By default, methods in interfaces are abstract and all the fields are public, static and final.
A class that implements an interface must implement all the methods declared in the interface using implements keyword.

use the following syntax to define interface in java :

S y n t a x

interface <interface_name>{  
        // declare constant fields  
        // declare methods that abstract   
        // by default.  
}

Java Interface Example

public interface play {

    final int a = 10;      // public, static and final

    void cricket();   // Abstract method
    void football(); // Abstract method
}

In this example, The play interface declares a constant 'a', which is public, static, and final, along with abstract methods cricket() and football().
Any class that implements the play interface must provide implementations for these methods.

Implementing Interfaces

To implement the play interface, you'll need to create a class that implements it and provide concrete implementations for the abstract methods.
A class uses the implements keyword to implement an interface . Let's say we have a class named "student" that implements the "play" interface:

public class student implements play {
    public void cricket() {
        System.out.println("student is playing cricket");
    }

    public void football() {
        System.out.println("student is playing football");
    }
}

By implementing the "play" interface, the "student" class must have to provide implementations for the cricket() and football() methods.

In Java, you cannot instantiate an interface directly; instead, you create instances of classes that implement the interface, allowing you to create references of the interface type and assign them to objects of implementing classes.

public class Main {
    public static void main(String[] args) {
        play student = new student(); // Instantiating the student class
        student.cricket(); // Output: student is playing cricket
        student.football(); // Output: student is playing football
    }
}

In the above example, student is a reference variable of type play, which is assigned an object of type student. Through this reference variable, you can call the cricket() and football() methods defined in the play interface, and the implementations provided in the student class will be executed.

New features added in interface from java 8

Java 8 introduced default and static methods as well as functional interfaces to enhance the versatility and power of interfaces.

1. Default Methods :

Interfaces can now have default methods, which provide a default implementation for a method. Default methods are declared using the default keyword and can be overridden by implementing classes if needed. This allows interfaces to evolve without breaking existing implementations.

public interface play {
    final int a = 10;      // public, static and final

    void cricket();   // Abstract method
    void football(); // Abstract method

    // Default method
    default void hockey() {
        System.out.println(" student playing hockey");
    }
}

In the above modification, I've added a default method named hockey to the play interface, which prints "student playing hockey" when invoked.

2. Satic Methods :

Java 8 introduced static methods in interfaces. These methods are declared using the static keyword and can be called directly on the interface, without requiring an instance of a class. Static methods in interfaces provide utility methods that are closely related to the interface's purpose.

public interface play {
    final int a = 10;      // public, static and final

    void cricket();   // Abstract method
    void football(); // Abstract method

    // Static method
    static void tennis() {
        System.out.println("student playing tennis");
    }
}

In the above modification, I've added a static method named tennis to the play interface, which prints "student playing tennis" when invoked.

3. Functional Interface

Java 8 introduced the concept of functional interfaces, which are interfaces that contain exactly one abstract method and may contain multiple default or static methods.
Functional interfaces enable the use of lambda expressions, providing a concise way to express instances of single-method interfaces. The @FunctionalInterface annotation was introduced to denote such interfaces, allowing the compiler to enforce the single abstract method requirement.

@FunctionalInterface   
public interface Play {    
     // Abstract methods                     
        void playGame();
}

Built-in Java Functional Interfaces

Runnable - This interface only contains the run() method.

Comparable - This interface only contains the compareTo()

method.

ActionListener – This interface only contains the actionPerformed() method.

Callable – This interface only contains the call() method.

Important points about interface

Thank you for taking the time to engage with my document! i hope that this overview has provided you with a clearer understanding of Java interfaces.

In our next blog post, we'll explore another method of achieving abstraction in Java: abstract classes. We'll also examine how abstract classes differ from interfaces, exploring their distinct approaches to abstraction. Stay tuned to enhance your understanding of these fundamental concepts of Java!

Records in java

Bhagyashri Birajdar — Sun, 19 Nov 2023 09:27:37 +0000

Introduction

In JAVA, record class is nothing but (immutable data) data carrying class between modules with the clear intention to reduce boilerplate code and achieve maximum efficiency.
Java Records is a feature introduced as a preview feature in Java 14 and became a standard feature in Java 16.

Reason behind why records introduced?

Before Java had record classes, if you wanted to create a class to hold data (like a person's name and id), you had to write a lot of repetitive code. This included making a constructor, getter and setter methods and if you want to print the contents of its objects as a string, we would need to override methods such as equals(), hashCode(), and toString().

let's understand above statement with example :-

Take a class 'person' with attributes for name and ID, providing methods to access these attributes and overriding methods like toString, hashCode, and equals for proper object representation, hashing, and value-based equality comparison respectively.


package p1;

import java.util.Objects;

class person {

    private final String name;
    private final int id;

// assinging values
    public person(String name, int id) {
        this.name = name;
        this.id = id;

    }

//for accesing values 
    public String getname() {
        return name;
    }

    public int getid() {
        return id;
    }

    // accessing content of object as string
    @Override
    public String toString() {
        return "person{" + "name=" + name + ", id='" + id + '\'' + '}';
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, id);
    }

    // to compare the value instead of mamory location
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        person pr = (person) obj;
        return id == pr.id && Objects.equals(name, pr.name);
    }

}

The 'Data_carry' class for demonstrating object creation and comparison using these overridden methods to check if two 'person' objects hold the same values, not just memory locations, facilitating value-based comparisons in Java.


public class Data_carry {

    public static void main(String[] args) {
        person obj1 = new person("birajdar", 10);
        person obj2 = new person("birajdar", 10);
        System.out.println("name = " + obj1.getname() + "\n" + "id = " + obj1.getid());
        System.out.println(obj1);
        System.out.print(obj1.equals(obj2));

    }

}

see, lot's of code we should write with simple java class to hold/carry some data.
To overcome this hadeche, JAVA introduced Recored class.

how to create record class?

Record class declaration part is slightly different from typical class declaration in java. means it quite similar to funtion.
Record class is create by using "record" keyword followed by "record_name" in its declaration.
In parentheses, parameters of this record class contain a comma separated list of fields.
Body of the record class is optional.

syntax :-


record record_name(List-of-fields){
// optional
}

how record class works?

Record class reduce boilerplate code by automatically compiler generate standard implementations for common tasks like constructors, getter(), setter() methods to access data, equals(), hashCode(), and toString() methods to access content of object as string without any intervention of the programmer. This allows developers to focus on defining the data fields and their behavior.

let's understand record class with example :-


package p1;

record Person(String name,int id){}    // record class
public class Data
{
    public static void main( String[] args )
    {
        Person obj1 = new Person("birajdar", 10);
        Person obj2 = new Person("birajdar",10);

        System.out.println("name = " + obj1.name() + "\n" + "age = " + obj1.id());
        System.out.println(obj1);
        System.out.print(obj1.equals(obj2));


    }
}

Explanation :-

In the above example a class 'Person' with name and ID attributes is created, showcasing object instantiation, attribute access, printing object details, and checking for equality in a concise and readable manner.

As we can see, we can reduce a complete class with a single line of code.

Important points about records

1) record class is immutable, meaning that once an object is created, its state cannot be changed.
2) A record class is instantiated by the new keyword, just like creating any other objects in Java.
3) records are implicitly final and cannot be extended by another class.
4) records cannot explicitly define additional instance variables beyond the automatically generated private final fields associated with their components.
5) Any other fields, except the list of components, must be declared static.
6) A record can implement one or more interface.
7) Records are serializable.

that's all about record now we will ready to learn, how record class and sealed interface works together? (prerequisite :- Sealed Interface)

Sealed interface with Record classes

To understand how record classes and sealed interfaces can work together, let's expand on the concept using an example.

let's consider an example where we create sealed interface "company" and then create record classes such as "manager" & "developer" that implement this interface & provide their own implementations for the info() method:


package p1;

sealed interface company permits Manager, developer {

    void work();
}

record Manager(String name, int age) implements company {

    @Override
    public void info() {
        System.out.println("Manager " + name + " (age: " + age + ") is managing teams.");

    }
}

record developer(String name, int age) implements company {

     @Override
    public void info() {
        System.out.println("Developer" + name + " (age: " + age + ") is working on coding tasks.");

    }
}

public class SealedInterface_RecordClass {
    public static void main(String[] args) {
        company obj1 = new Manager("paradox", 45);
        company obj2 = new developer("max", 30);

        obj1.info();
        obj2.info();
    }
}

Advantages of Sealed Interfaces with Record Classes

1) Structural Consistency: Sealed interfaces maintain a controlled hierarchy by defining which classes can implement them.

2) Reduced Boilerplate: Records reduce repetitive code by and enhancing code readability.

3) Enhanced Readability: Sealed interfaces clarify class relationships, while records simplify the creation of immutable data models.

Thanks 🙏 for reading! Hopefully, this article helps you to understand Record class in Java. Please submit any suggestions or comments you may have in the comment section of this article.

Can Sealed Interfaces in Java Improve Code Security?

Bhagyashri Birajdar — Fri, 06 Oct 2023 16:42:11 +0000

In the field of software development, security and robustness are of utmost importance to protect against potential vulnerabilities.

Sealed interfaces in Java17 are a simple & powerful way to enhance code security.

In our previous blog post, We covered the concept of Sealed Classes. Now, it's time to turn our attention towards sealed interfaces & how they improve code security. But before that, you must have an idea about what an interface is.

In Java 17, sealed classes and sealed interfaces share similar rules and behavior.

Like sealed classes, to seal an interface, add the sealed keyword to it's declaration. After "extends" statement, include a permits clause (If there are no "extends" statements, you can skip that part). permits clause tells which classes are allowed to implement this sealed interface and which interfaces can extend it.

When an interface is marked as sealed, any class or interface attempting to implement or extend it must be listed in the permits clause of the sealed interface. Otherwise, it will result in a compilation error.

This way, you control who can work with your interface, ensuring everything stays well-organized and secure.

syntax

public sealed interface Interface_Name permits Subinterface1, Subinterface2, ... {
    // Interface members and methods
}

example

sealed interface Color permits Red, Green {
    default void display() {
        System.out.print("This is Color interface");
    }
}

This Java code defines a sealed interface named "Color" that permits implementation by the interface "Red" and the class "Green". It includes a default "display()" method which prints "This is Color interface" when called.

non-sealed interface Red extends Color {
    default void show() {
        System.out.println("This is Red interface");
    }
}

This code defines a non-sealed interface named "Red" which extends the "Color" interface. It includes a default method "show()" that prints "This is Red interface" when called.

final class Green implements Color {
    public void play() {
        System.out.println("This is Green class");

    }
}

The code defines a final class named "Green" which implements the interface "Color". It includes a method "play()" that prints "This is Green class". The use of final means that "Green" class cannot be subclassed or extended further.

Code Execution

public class Main {
    public static void main(String[] args) {
        Color obj2 = new Green();
        obj2.display();

    }
}

Output

This is Color interface

Records can be used with Sealed Interfaces. In our next blog post, we'll explore what a record is and how records and sealed interfaces work together. Gear up for an exciting exploration of these Java features! Stay tuned!

Java17 sealed classes

Bhagyashri Birajdar — Sat, 23 Sep 2023 10:14:00 +0000

Are Java 17 Sealed Classes a Game-Changer for Inheritance Control?

Introduction:-

Sealed classes are a feature introduced in Java 16 (as a preview feature) and finalized in Java 17.
In this complete blog tutorial, we'll see what sealed classes are and why they're useful. But first, let's start with the basic definition of a sealed class.

Sealed class:-

"Sealed class offer a powerful mechanism to restrict the inheritance hierarchy. "
Which means, When you want's inheritance but not all classes can do it, their should be a limited classes which you want's to be inherited. then you can do this by using sealed class.
Declaration of sealed class is not much complicated. simply you just need to add the sealed keyword to it's declaration.
After the class declaration add permits clause to give the permission to those sub-classes which you want's to be inherited.
Only permitted classes can have the access to extends the sealed class.

Syntax :-

public sealed class Class_Name permits Subclass1, Subclass2, ... {
    // Class members and methods
}

ex :-

sealed class Color permits Red, Green, Blue {
    public void display() {
        System.out.print("This is Color class");
    }
}

in the above example we can see that the Color class is a sealed class that give the permission to Red & Green classes to extends it. If any other class tries to extend it, then it will give a compiler error.
A class that extends a sealed class must have either final , sealed or non-sealed keyword in its declaration.

1) sealed :-
sealed class can only be extended by it's permitted sub-classes.

sealed class Red extends Color permits R {
    public void display() {
        System.out.println("This is Red class");
    }
}

The code defines a sealed class "Red" extending it's super-class "Color" and permitting only class "R", with a display method printing "This is Red class".

final class R extends Red{
    public void display() {
        System.out.println("This is R class");
    }
}

The code defines a final class "R" that extends the sealed class "Red" and overrides the display method to print "This is R class".

2) non-sealed :-
non-sealed class can be extends by any sub-class. a sealed class cannot prevent its permitted sub-classes from doing this.

non-sealed class Green extends Color {
    public void display() {
        System.out.println("This is Green class");
    }
}

The code defines a non-sealed class "Green" that extends it's super-class "Color" and contains a display method which prints "This is Green class".

3) final :-
final class can't be inherited further.

final class Blue extends Color {
    public void display() {
        System.out.println("This is Blue class");
    }
}

The code defines a final class "Blue" that extends it's super-class "Color" and contains a display method which prints "This is Blue class". This means that the class "Blue" cannot be subclassed further.

Code Execution



public class Main
{
    public static void main(String[] args)
    {   
        Color obj1 = new Red();
        Color obj2 = new Green();
        Color obj3 = new Blue();

        obj1.display();
        obj2.display();
        obj3.display();

        Red r = new R();
        r.display();

    }
}

Output :-

This is Red class
This is Green class
This is Blue class
This is R class

features

Sealed classes helps in creating a finite set of classes in inheritance.
Sealed classes specify which classes can extend them, providing a clear hierarchy.
Sealed classes ensure that only permitted sub-classes are created, avoiding unexpected behavior.
Useful for creating frameworks, allowing developers to dictate which classes users can extend.
Especially beneficial in large projects, it prevents unintentional changes to important classes.

Note:-
- Sealed class must specify it's permitted sub-class using permits clause.
- Sealed class must have sub-classes.
- Only the listed sub-classes are allowed to extend the sealed class.
- Permitted sub-classes must be in same package.
- Permitted sub-classes should extends their sealed super class directly.

conclusion

sealed classes in Java provide a powerful tool for controlling class hierarchies. They allow us to explicitly specify which classes can extend a particular class, offering a clear and organized structure for our code. This feature is valuable in preventing unintended subclasses and maintaining code integrity.

Thanks for reading! Hopefully, this article helps you to understand sealed class in Java17. Please submit any suggestions or comments you may have in the comment section of this article and don't forget to hit the ❤️ like.
Thank you.😀

sealed interface