Java Virtual Threads: Avoid the Pinning Problem

Day 41 — LeetCode Progress (Java) Problem: Find the Duplicate Number Required: Given an array containing n + 1 integers where each integer is in the range [1, n], return the duplicate number. Idea: Use binary search on the value range. If the count of numbers ≤ mid exceeds mid, the duplicate lies in the left half; otherwise it lies in the right half. Approach: Initialize low = 1 and high = n - 1. While low < high: Compute mid. Count how many numbers in the array are ≤ mid. If count > mid, move high = mid. Otherwise move low = mid + 1. When the loop ends, low will be the duplicate number. Time Complexity: O(n log n) Space Complexity: O(1) #LeetCode #DSA #Java #BinarySearch #Arrays #CodingJourney #100DaysOfCode

🚀 Java 21 Concurrency Experiment: Virtual Threads vs Traditional Approaches I built a small lab to compare different concurrency strategies in Java under a mixed workload. Technologies tested: • ExecutorService (Fixed thread pools) • CompletableFuture • Parallel Streams • Virtual Threads (Java 21) The goal was simple: measure execution time, throughput, and memory usage while processing concurrent tasks. Some interesting observations: ⚡ Virtual Threads handled thousands of tasks with significantly higher throughput ⚡ Traditional thread pools performed well but required careful sizing ⚡ CompletableFuture and Parallel Streams were easier to use but less predictable under heavier loads In one of the mixed workload scenarios: Virtual Threads reached 16k+ ops/s, significantly outperforming the other approaches. This experiment reinforced something important: Concurrency model choice can dramatically impact system scalability. Code + experiment details: https://lnkd.in/dYeyu4Pd #Java #Java21 #BackendEngineering #Concurrency #Performance #SoftwareEngineering

Concurrency is one of the most powerful features of Java, but it’s also a "hazard zone" for shared state. If you’ve ever dealt with a bug that only happens in production under high load, you’ve likely met a Race Condition or a Memory Visibility Failure. This guide perfectly visualizes the three pillars of fixing thread-safe issues: Don’t Share: If a variable is confined to a single thread, it can't be corrupted. Immutability: You can’t break what doesn’t change. Use final liberally. Synchronize: When you must share, use intrinsic locking to ensure atomic access. Writing concurrent code isn't just about making things "fast"—it's about making them predictable. #Java #Concurrency #Multithreading #SoftwareEngineering #CleanCode

Java 21 just made most reactive frameworks obsolete. 🔥 I said it. For years we tortured ourselves with WebFlux, reactive streams, and callback hell — all to avoid blocking threads and handle high concurrency. Then Java 21 dropped Virtual Threads and said: "Hold my coffee." ☕ Virtual Threads in a nutshell: - Managed by the JVM, not the OS - You can spin up MILLIONS of them - Write plain blocking code — JVM handles the rest - Zero reactive syntax. Zero mental overhead. Old world: return Mono.fromCallable(() -> userRepo.findById(id)) .subscribeOn(Schedulers.boundedElastic()) .flatMap(user -> Mono.just(mapToDto(user))); New world: User user = userRepo.findById(id); // Just... this. ✅ return mapToDto(user); Same concurrency. Same performance. 10x simpler code. Does this mean reactive is dead? Not entirely — event-driven systems still have their place. But for most REST APIs and microservices? Virtual Threads win. Every time. Change my mind. 👇 #Java #Java21 #VirtualThreads #SpringBoot #BackendDevelopment #SoftwareEngineering #Programming

🚀 Building a Multi-Threaded Server using Java Virtual Threads Recently, I built a multi-threaded TCP server in Java using Virtual Threads to understand how modern concurrency works. Traditional servers usually rely on platform threads, which are limited because each thread is tied to an OS thread. This can become expensive when handling thousands of connections. With Virtual Threads (introduced in Java 21), things become much more efficient. Here’s what I explored while building this project: 🔹 Implemented a TCP client-server communication system 🔹 Used Virtual Threads to handle multiple client requests concurrently 🔹 Compared the behavior with traditional platform threads 🔹 Learned how lightweight threads improve scalability and resource utilization 💡 Key takeaway: Virtual Threads make it possible to write simple concurrent code while supporting massive numbers of tasks with minimal overhead. This project helped me better understand: • Concurrency in Java • Thread management • Client-server communication • Real-world backend system behavior I’m currently exploring more backend concepts and building projects to strengthen my understanding of Java and distributed systems. #Java #VirtualThreads #BackendDevelopment #Java21 #ComputerScience #LearningInPublic

🚀 What’s new in Java 26? This is not an LTS release, but it gives a very clear picture of where Java is heading. The main highlights are HTTP/3 in HttpClient, Ahead-of-Time Object Caching for any GC, a stricter direction around final, and the final removal of the Applet API. ⚙️ What also stands out is how many practical improvements landed around GC. According to the HotSpot GC overview, around 380 issues were closed in the GC subcomponent. GC CPU time accounting was improved, a new JFR event for string deduplication was added, and G1 received changes that reduce synchronization between the application and GC to improve throughput. 🧩 Java is also moving forward with Structured Concurrency, Lazy Constants, Vector API, and primitive patterns. #Java #JDK26 #OpenJDK #Backend #SoftwareEngineering

Day 39 — LeetCode Progress (Java) Problem: Find First and Last Position of Element in Sorted Array Required: Return the starting and ending position of a target value in a sorted array. If the target is not found, return [-1, -1]. Idea: Traverse the array and track the first and last occurrence of the target while iterating. Approach: Initialize result array as [-1, -1]. Traverse the array from left to right. When the target is found for the first time, update both positions. For subsequent matches, update the ending index. Continue until the end of the array. Time Complexity: O(n) Space Complexity: O(1) Note: This approach works but is not the optimized solution for this problem. The next post will cover the optimized solution. #LeetCode #DSA #Java #Arrays #CodingJourney #100DaysOfCode

JavaTip #5 – Understanding Virtual Threads in Java 21 One of the most interesting improvements introduced in Java 21 is Virtual Threads, part of Project Loom. Traditionally, Java applications used platform threads managed by the operating system. While powerful, these threads are relatively expensive in terms of memory and resource usage. Because of this, backend systems often rely on thread pools to limit the number of concurrent threads. But this approach also adds complexity when applications need to handle thousands of concurrent requests. Virtual Threads change this model. They are lightweight threads managed by the JVM rather than the operating system. This means an application can create thousands or even millions of virtual threads without the heavy overhead associated with traditional threads. Why this matters for backend systems: 🔹 Better scalability Applications handling many I/O operations (such as database calls, APIs, or network communication) can benefit significantly from virtual threads. 🔹 Simpler concurrency model Developers can write straightforward, blocking-style code without worrying too much about complex thread pool management. 🔹 Efficient resource usage Virtual threads consume far fewer resources compared to platform threads. Example idea: Instead of managing a fixed thread pool manually, developers can allow the JVM to handle concurrency more efficiently using virtual threads. However, like any technology, they should be used thoughtfully. CPU-heavy tasks still need proper design, and understanding when to use virtual threads is important. Modern Java is evolving rapidly, and features like Virtual Threads show how the language continues to improve scalability while keeping the developer experience simple. #JavaTip #Java21 #VirtualThreads #BackendDevelopment #SoftwareEngineering #JavaDeveloper #OpenToWork

Day 38 — LeetCode Progress (Java) Problem: Successful Pairs of Spells and Potions Required: For each spell, find how many potions form a successful pair such that spell × potion ≥ success. Idea: Sort the potions array so binary search can be used to find the first valid potion that satisfies the condition. Approach: Sort the potions array. For each spell, perform binary search on potions. Find the smallest index where spell × potion ≥ success. All potions to the right of that index form valid pairs. Store the count in the result array. Time Complexity: O(n log m) Space Complexity: O(1) (excluding output array) #LeetCode #DSA #Java #BinarySearch #Arrays #CodingJourney #100DaysOfCode

⚡ Java Multithreading vs Virtual Threads — explained simply For years in Java, concurrency meant using traditional platform threads. But with Virtual Threads, things are getting much simpler. Here’s the difference 👇 🧵 Traditional Threads • Heavyweight (each thread uses OS resources) • Limited scalability • Requires thread pools and careful management • Too many threads → performance issues ⚡ Virtual Threads • Lightweight threads managed by the JVM • Can run thousands or even millions of tasks • Simpler concurrency model • Write code in a normal synchronous style 💡 Why this matters for backend developers Applications like web servers and microservices handle thousands of requests concurrently. Virtual Threads allow us to scale much better without complex async code. 📚 In short Traditional Threads → Limited & heavy Virtual Threads → Scalable & lightweight One of the most exciting improvements in modern Java. Are you planning to try Virtual Threads in your projects? #Java #JavaDeveloper #BackendDevelopment #VirtualThreads #SoftwareEngineering #Programming #dsacoach #coding #programming