BestHub
Sign in
Tagged articles

virtual-threads

136 articles · Page 1 of 2
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 10, 2026 · Backend Development

Spring Boot API Aggregation: Sequential, CompletableFuture, and Virtual Thread Structured Concurrency Performance

The article benchmarks three Spring Boot aggregation approaches—sequential calls, CompletableFuture parallelism, and virtual‑thread structured concurrency—using JMeter on a Spring Boot 3.5.0 service, showing that CompletableFuture delivers the lowest latency, structured concurrency offers better reliability, and sequential execution performs the worst.

CompletableFutureJMeterSpring Boot
0 likes · 7 min read
Spring Boot API Aggregation: Sequential, CompletableFuture, and Virtual Thread Structured Concurrency Performance
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 4, 2026 · Backend Development

5 Advanced Spring Boot Patterns for Millisecond API Responses

This article presents five advanced Spring Boot 3.5.0 patterns—ETag with conditional requests, read‑write separation, virtual threads, HTTP client connection reuse, and asynchronous processing—to achieve sub‑millisecond API response times, complete with code examples, configuration steps, and performance benefits.

ETagRead‑Write SplittingSpring Boot
0 likes · 15 min read
5 Advanced Spring Boot Patterns for Millisecond API Responses
Su San Talks Tech
Su San Talks Tech
Jun 1, 2026 · Backend Development

Can Java 21’s Virtual Threads Make Thread Pools Obsolete?

The article examines whether Java 21’s cheap virtual threads can replace traditional thread pools, explaining the original purpose of pools, their role as natural throttlers, scenarios where virtual threads excel or fail, and practical guidelines to avoid pitfalls like pinning.

JavaJava 21concurrency
0 likes · 7 min read
Can Java 21’s Virtual Threads Make Thread Pools Obsolete?
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
May 22, 2026 · Fundamentals

Upgrade from Java 8: 8 Powerful Features in Java 21 You Should Know

The article examines why many projects still cling to Java 8 and demonstrates eight transformative Java 21 features—including records, sealed classes, pattern‑matching for instanceof, switch expressions, text blocks, virtual threads, structured concurrency, and enhanced APIs—showing code examples and the benefits they bring to performance, readability, and maintainability.

JavaJava 21Records
0 likes · 11 min read
Upgrade from Java 8: 8 Powerful Features in Java 21 You Should Know
Senior Xiao Ying
Senior Xiao Ying
May 8, 2026 · Backend Development

Spring Boot 4.0 with JDK 21 and Virtual Threads: Boosting Performance

Spring Boot 4.0 introduces a milestone upgrade that requires JDK 21, switches to jakarta.* packages, offers first‑class virtual‑thread support, a built‑in declarative HTTP client, native retry annotations, API versioning, and modular auto‑configuration, all aimed at higher cloud‑native performance.

Declarative HTTP ClientJDK 21Modular Auto-Configuration
0 likes · 11 min read
Spring Boot 4.0 with JDK 21 and Virtual Threads: Boosting Performance
Programmer XiaoFu
Programmer XiaoFu
May 8, 2026 · Backend Development

Can Java 21 Virtual Threads Render Thread Pools Obsolete?

The article examines how Java 21’s cheap virtual threads change the role of traditional thread pools, explaining why pooling virtual threads is a bad idea, how thread pools still act as natural throttlers, and which scenarios—especially CPU‑bound work and synchronized blocks—remain unsuitable for virtual threads.

JDK 21JavaPinning
0 likes · 8 min read
Can Java 21 Virtual Threads Render Thread Pools Obsolete?
TonyBai
TonyBai
May 7, 2026 · Backend Development

Why an AWS Evangelist Calls Go’s Concurrency a Joke Compared to JVM’s Superior Model

The article revisits the heated debate sparked by AWS evangelist James Ward, who argues that Go’s concurrency primitives are inferior to the JVM’s virtual threads, structured concurrency, and effect systems, using a demanding connection‑pool challenge to illustrate the trade‑offs and guide architects in choosing the right model for their workloads.

Effect SystemsGoGoroutine
0 likes · 11 min read
Why an AWS Evangelist Calls Go’s Concurrency a Joke Compared to JVM’s Superior Model
Java Tech Enthusiast
Java Tech Enthusiast
May 6, 2026 · Backend Development

Spring Boot 4.1’s Default Virtual Threads Boost Throughput—But Require HikariCP Tuning

Spring Boot 4.1 makes virtual threads the default, dramatically increasing I/O concurrency, yet the unchanged HikariCP maximumPoolSize can exhaust connections; the article explains this incompatibility, shows how to adjust pool settings, enable lazy connections, and outlines a step‑by‑step migration path from 3.x to 4.1.

HikariCPJava 21LazyConnection
0 likes · 19 min read
Spring Boot 4.1’s Default Virtual Threads Boost Throughput—But Require HikariCP Tuning
Java Architect Handbook
Java Architect Handbook
Apr 24, 2026 · Interview Experience

Why Use Coroutines When Threads Already Exist? Java Interview Deep Dive

An interview‑focused analysis explains how processes allocate resources, threads handle CPU scheduling, and coroutines act as lightweight user‑mode threads, comparing their creation costs, switching overhead, and memory usage, and highlights Java 19/21 virtual threads as the Java implementation of coroutines.

Javaconcurrencycoroutine
0 likes · 13 min read
Why Use Coroutines When Threads Already Exist? Java Interview Deep Dive
java1234
java1234
Apr 16, 2026 · Backend Development

Why Java Virtual Threads? Deep Dive into Loom’s Principles and Production Pitfalls

The article explains why traditional platform threads are costly, defines Java virtual threads as lightweight JVM‑managed threads that unmount on blocking, compares their performance and limits to platform threads, outlines suitable and unsuitable use cases, provides starter code and best‑practice patterns, and offers a detailed production‑ready checklist to avoid common pitfalls such as pinning, ThreadLocal misuse, and blocking I/O.

JavaPinningProduction
0 likes · 16 min read
Why Java Virtual Threads? Deep Dive into Loom’s Principles and Production Pitfalls
JakartaEE China Community
JakartaEE China Community
Apr 8, 2026 · Backend Development

From Reactive Streams to Virtual Threads: A Deep Dive

The article examines Project Loom's virtual threads, compares them with reactive streams, explores their underlying mechanisms, presents a direct‑style flow library (Jox) that combines both paradigms, and evaluates performance, backpressure, and error handling in Java concurrency.

JavaJoxProject Loom
0 likes · 22 min read
From Reactive Streams to Virtual Threads: A Deep Dive
LuTiao Programming
LuTiao Programming
Mar 26, 2026 · Backend Development

5 Overlooked Java Features That Are Silently Slowing Your JVM

The article demonstrates how five often‑ignored Java 21 capabilities—virtual threads, structured concurrency, ZGC, records, and pattern matching—can dramatically improve throughput and stability, while neglecting them silently degrades JVM performance.

JVMJavaPattern Matching
0 likes · 7 min read
5 Overlooked Java Features That Are Silently Slowing Your JVM
LuTiao Programming
LuTiao Programming
Mar 15, 2026 · Backend Development

How Java Virtual Threads Eliminate Thread‑Pool Bottlenecks and Enable a Single Machine to Handle 100k Requests

The article explains why traditional OS‑based thread pools choke under 100,000 concurrent Java requests, introduces Java 21's Virtual Threads from Project Loom, shows their low‑memory, high‑throughput characteristics, provides Spring Boot configuration and code samples, and warns about synchronization, ThreadLocal and CPU‑bound pitfalls.

I/OJavaProject Loom
0 likes · 10 min read
How Java Virtual Threads Eliminate Thread‑Pool Bottlenecks and Enable a Single Machine to Handle 100k Requests
LuTiao Programming
LuTiao Programming
Mar 2, 2026 · Backend Development

How a Targeted Java Refactor Delivered a 10× Performance Boost

By profiling a three‑year‑old order service and applying six data‑driven optimizations—including log reduction, object‑allocation cuts, HashMap replacement, Java 21 virtual threads, JSON caching, and ZGC tuning—the team achieved a 9.5× throughput increase and a ten‑fold drop in P99 latency.

Eclipse CollectionsGC TuningJava
0 likes · 8 min read
How a Targeted Java Refactor Delivered a 10× Performance Boost
Ops Community
Ops Community
Mar 2, 2026 · Backend Development

How to Supercharge Tomcat 11 on JDK 21: Real‑World JVM, Connection Pool, and Virtual Thread Tuning

This guide walks you through practical performance tuning of Tomcat 11 on JDK 21, covering JVM memory settings, GC selection, connector and thread‑pool optimization, virtual‑thread integration, benchmark scripts, security hardening, high‑availability deployment, and comprehensive monitoring and troubleshooting techniques.

DockerG1 GCJDK21
0 likes · 51 min read
How to Supercharge Tomcat 11 on JDK 21: Real‑World JVM, Connection Pool, and Virtual Thread Tuning
Xiaohongshu Tech REDtech
Xiaohongshu Tech REDtech
Jan 30, 2026 · Backend Development

How Java Virtual Threads Cut Latency by 31× and Slash CPU Use in Production

This article explains the principles of Java virtual threads, compares them with traditional platform threads, details RedJDK21’s implementation and performance improvements—including up to 31‑fold latency reduction and 24% CPU savings—in large‑scale services at XiaoHongShu, and discusses migration challenges, lock handling, monitoring, and future roadmap.

JVMJavaPerformance Optimization
0 likes · 29 min read
How Java Virtual Threads Cut Latency by 31× and Slash CPU Use in Production
macrozheng
macrozheng
Jan 27, 2026 · Backend Development

Why Tomcat Beats Jetty 15× with SpringBoot 4 Virtual Threads

A performance comparison of SpringBoot 4.0 with virtual threads shows Tomcat achieving up to fifteen times higher QPS than Jetty, while startup times remain similar, and provides step‑by‑step instructions for building native Docker images and switching containers.

DockerJettyNative Image
0 likes · 10 min read
Why Tomcat Beats Jetty 15× with SpringBoot 4 Virtual Threads
LuTiao Programming
LuTiao Programming
Jan 23, 2026 · Backend Development

Are You Still Using Old Java Patterns? 2026 Spring Boot Trends That May Obsolete Them

The article analyzes how Spring Boot 2026 reshapes Java backend development by embracing virtual threads, GraalVM native images, built‑in observability, modern security practices, immutable records, and cloud‑native defaults, urging developers to abandon legacy coding habits in favor of these emerging trends.

Cloud NativeGraalVMNative Image
0 likes · 8 min read
Are You Still Using Old Java Patterns? 2026 Spring Boot Trends That May Obsolete Them
Java Web Project
Java Web Project
Jan 13, 2026 · Backend Development

Mastering Spring 6 & Boot 3: Virtual Threads, Declarative HTTP, GraalVM Native Images, and Advanced Monitoring

This article walks through Spring 6’s core upgrades—including JDK 17 baseline, Project Loom virtual threads, @HttpExchange declarative clients, RFC 7807 ProblemDetail handling, GraalVM native‑image compilation, and Micrometer‑Prometheus monitoring—showing concrete code, performance numbers, migration steps, and real‑world e‑commerce use cases.

GraalVMHTTP ClientMonitoring
0 likes · 8 min read
Mastering Spring 6 & Boot 3: Virtual Threads, Declarative HTTP, GraalVM Native Images, and Advanced Monitoring
Java Architecture Diary
Java Architecture Diary
Jan 8, 2026 · Backend Development

Why Tomcat Outperforms Jetty 15× with Virtual Threads in Spring Boot 4.0

A detailed benchmark shows that enabling Java virtual threads in Spring Boot 4.0 makes Tomcat handle up to fifteen times more requests than Jetty, while startup times remain similar, and the article explains the test setup, configuration steps, native image builds, and the reasons behind Jetty's limitation.

DockerJettyNative Image
0 likes · 10 min read
Why Tomcat Outperforms Jetty 15× with Virtual Threads in Spring Boot 4.0
Java Web Project
Java Web Project
Jan 4, 2026 · Backend Development

Unlock Spring 6 & Boot 3: Virtual Threads, Declarative HTTP, and GraalVM Native Images

This article walks through the core upgrades in Spring 6 and Spring Boot 3—raising the JDK baseline, adopting Project Loom virtual threads, using the new @HttpExchange declarative client, standardizing error responses with ProblemDetail, compiling to GraalVM native images, and adding Prometheus monitoring—while providing concrete code examples, performance numbers, and a step‑by‑step migration roadmap.

Cloud NativeGraalVMMicroservices
0 likes · 8 min read
Unlock Spring 6 & Boot 3: Virtual Threads, Declarative HTTP, and GraalVM Native Images
Tech Freedom Circle
Tech Freedom Circle
Dec 30, 2025 · Backend Development

How Java Virtual Threads Supercharge Spring Boot: 3× QPS Boost and 67% Memory Savings

This article explains how Java's new virtual threads (Project Loom) can transform Spring Boot applications, delivering up to three‑fold QPS improvements and up to 67% lower memory usage, by replacing heavyweight platform threads with lightweight coroutine‑style execution, and provides detailed comparisons, benchmarks, code samples, and migration guidance.

JavaProject LoomSpring Boot
0 likes · 51 min read
How Java Virtual Threads Supercharge Spring Boot: 3× QPS Boost and 67% Memory Savings
LuTiao Programming
LuTiao Programming
Dec 14, 2025 · Backend Development

How Spring 6 + Boot 3 Supercharges Startup Speed and Concurrency

The article dissects Spring 6 and Boot 3's core capabilities—JDK 17 baseline, Project Loom virtual threads, declarative @HttpExchange client, RFC 7807 error standardization, GraalVM native images, Jakarta EE 9 migration, and Prometheus monitoring—showing benchmark gains and a migration roadmap for high‑concurrency e‑commerce services.

GraalVMJavaSpring
0 likes · 9 min read
How Spring 6 + Boot 3 Supercharges Startup Speed and Concurrency
Java Tech Enthusiast
Java Tech Enthusiast
Dec 7, 2025 · Backend Development

Spring Boot 4.0 GA: New Features, Performance Boosts, and Migration Guide

Spring Boot 4.0 GA introduces a modern Java baseline, native virtual‑thread support, GraalVM native image integration, streamlined API versioning, a lightweight @HttpExchange client, enhanced security and observability features, and a list of breaking changes, with migration guidance for developers.

Cloud NativeGraalVMJava
0 likes · 8 min read
Spring Boot 4.0 GA: New Features, Performance Boosts, and Migration Guide
Java Architecture Diary
Java Architecture Diary
Nov 28, 2025 · Backend Development

Why Spring Cloud 2025.1.0 Is a Major Breakthrough (and What’s Gone)

Spring Cloud 2025.1.0 (Oakwood) marks a true major release built on Spring Boot 4.0 and Spring Framework 7, removing many legacy components, embracing Java 21 virtual threads, and integrating core features directly into the framework, fundamentally reshaping microservice development.

Backend DevelopmentMicroservicesSpring Boot 4
0 likes · 10 min read
Why Spring Cloud 2025.1.0 Is a Major Breakthrough (and What’s Gone)
Java Tech Enthusiast
Java Tech Enthusiast
Oct 26, 2025 · Fundamentals

Is Java 8 Dead? Discover All New Features from Java 8 to Java 24

This comprehensive guide walks you through the evolution of Java from version 8 to 24, highlighting key language enhancements, new APIs, and performance improvements such as lambda expressions, Stream API, records, sealed classes, virtual threads, and the latest features that modernize Java development for today’s programmers.

JavaJava 8Records
0 likes · 46 min read
Is Java 8 Dead? Discover All New Features from Java 8 to Java 24
21CTO
21CTO
Oct 16, 2025 · Backend Development

Top 7 Java Microframeworks for Modern Lightweight Apps – A Deep Dive

This article reviews seven popular Java micro‑frameworks, comparing their popularity, key advantages, and GitHub repositories, while highlighting performance benefits of GraalVM native images and the impact of Java 21 virtual threads for cloud‑native, lightweight web applications.

GraalVMJavaSpring Boot
0 likes · 15 min read
Top 7 Java Microframeworks for Modern Lightweight Apps – A Deep Dive
JavaGuide
JavaGuide
Oct 16, 2025 · Backend Development

Why Upgrading from Java 8 to Java 21 Boosts Development Efficiency

The article walks through the evolution from Java 8 to Java 21, comparing preview and standard features such as pattern‑matching instanceof, switch expressions, text blocks, the new HttpClient API, var type inference, virtual threads, records, immutable collections, improved try‑with‑resources, sequenced collections, and garbage‑collector enhancements, illustrating each with concrete code examples and practical recommendations.

JavaJava 21Pattern Matching
0 likes · 16 min read
Why Upgrading from Java 8 to Java 21 Boosts Development Efficiency
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Sep 26, 2025 · Backend Development

Boost Spring Batch Performance: Async & Virtual Threads in Spring Boot 3

This article demonstrates how to accelerate Spring Batch jobs in Spring Boot 3 by comparing a default synchronous job with asynchronous processing using ThreadPoolTaskExecutor and then with virtual threads, providing code examples, configuration steps, and performance results that show up to a 90‑fold speedup.

Async ProcessingSpring Batchspring-boot-3
0 likes · 9 min read
Boost Spring Batch Performance: Async & Virtual Threads in Spring Boot 3
Java Architecture Diary
Java Architecture Diary
Sep 22, 2025 · Backend Development

Unlock Massive Concurrency: How Java 25 Virtual Threads Supercharge Spring Apps

Java 25 introduces major upgrades to virtual threads, offering dramatically lower memory usage, near‑zero creation cost, and efficient I/O handling, and this guide explains their advantages, compares them with traditional thread pools and @Async, provides Spring Boot 3.5 configuration examples, and highlights pitfalls and best‑practice tips.

Springconcurrencythread pool
0 likes · 8 min read
Unlock Massive Concurrency: How Java 25 Virtual Threads Supercharge Spring Apps
macrozheng
macrozheng
Aug 13, 2025 · Backend Development

What’s New in IntelliJ IDEA 2025.2? AI Coding, Java 25, Maven 4, and More

IntelliJ IDEA 2025.2 introduces major AI‑assisted coding upgrades, full Java 25 support, early Maven 4 compatibility, JSpecify nullability annotations, a Spring debugger, virtual‑thread debugging enhancements, and highlights a popular open‑source SpringBoot3 + Vue e‑commerce project for developers.

IntelliJ IDEAJava 25Maven 4
0 likes · 7 min read
What’s New in IntelliJ IDEA 2025.2? AI Coding, Java 25, Maven 4, and More
JakartaEE China Community
JakartaEE China Community
Aug 5, 2025 · Operations

How to Monitor Java Virtual Threads Effectively

This article explains the internal mechanics of Java virtual threads, the role of Continuation, pinned threads, and carrier threads, and provides concrete monitoring techniques using JVM flags, JFR events, and framework-specific considerations for Helidon and Quarkus.

ForkJoinPoolHelidonJFR
0 likes · 11 min read
How to Monitor Java Virtual Threads Effectively
Xiaohongshu Tech REDtech
Xiaohongshu Tech REDtech
Jul 24, 2025 · Backend Development

How Xiaohongshu Boosted Java Performance by 10% with a RedJDK Upgrade

Xiaohongshu’s middleware team migrated thousands of Java services from JDK 8 to RedJDK 11/17, achieving over 10% performance gains, 50% GC pause reduction, and eliminating OOM crashes through systematic JDK upgrades, GC tuning, native‑memory improvements, and standardized deployment pipelines.

GC optimizationNative Memorybackend services
0 likes · 22 min read
How Xiaohongshu Boosted Java Performance by 10% with a RedJDK Upgrade
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jul 19, 2025 · Backend Development

How Virtual Threads Boost Spring Boot 3 Performance: Real-World Benchmarks

This article demonstrates how Spring Boot 3.2.5 leverages JDK 21 virtual threads to improve asynchronous request handling, comparing platform‑thread and virtual‑thread performance with JMeter, exploring thread‑pool configurations, database access tests, and providing practical code examples and tuning tips.

Async RequestsJMeterSpring Boot
0 likes · 9 min read
How Virtual Threads Boost Spring Boot 3 Performance: Real-World Benchmarks
Architect
Architect
Jul 13, 2025 · Backend Development

Master Spring 6 & Spring Boot 3: Core Features, Virtual Threads, GraalVM & More

This article provides a comprehensive overview of the Spring ecosystem upgrade, detailing Spring 6 core features such as JDK 17 baseline, Project Loom virtual threads, declarative HTTP clients, RFC‑7807 ProblemDetail handling, GraalVM native images, as well as Spring Boot 3 breakthroughs like Jakarta EE migration, OAuth2 server, Prometheus monitoring, and practical migration roadmaps for cloud‑native applications.

GraalVMMicroservicesSpring
0 likes · 8 min read
Master Spring 6 & Spring Boot 3: Core Features, Virtual Threads, GraalVM & More
Java Backend Technology
Java Backend Technology
Jul 8, 2025 · Backend Development

ThreadLocal vs ScopedValue: Why ScopedValue Is the New King in Java Concurrency

ThreadLocal has long served as Java’s go‑to tool for thread‑local data, but its memory‑leak risks and performance penalties become pronounced with virtual threads, while the newer ScopedValue offers automatic cleanup, immutable safety, and superior efficiency, making it a compelling replacement in high‑concurrency scenarios.

ScopedValueThreadLocalconcurrency
0 likes · 12 min read
ThreadLocal vs ScopedValue: Why ScopedValue Is the New King in Java Concurrency
macrozheng
macrozheng
Jun 3, 2025 · Backend Development

Discover Spring Boot 4.0 Snapshot: New API Versioning, Virtual Threads & More

Spring Boot 4.0 (SNAPSHOT) introduces built‑in Spring Framework 7.0 support, elegant API versioning via @RequestMapping, flexible bean registration, virtual thread integration for massive concurrency, JSpecify null‑safety annotations, enhanced SPEL, Jackson 3.x migration, servlet upgrades, and native GraalVM image support, all illustrated with code samples.

JSpecifySpELSpring Boot
0 likes · 7 min read
Discover Spring Boot 4.0 Snapshot: New API Versioning, Virtual Threads & More
Architecture Digest
Architecture Digest
May 28, 2025 · Backend Development

Spring 6.0 Core Features and Spring Boot 3.0 Breakthroughs: Virtual Threads, Declarative HTTP Clients, ProblemDetail, GraalVM Native Images, and Monitoring

This article explains the major enhancements in Spring 6.0 and Spring Boot 3.0—including a JDK 17 baseline, Project Loom virtual threads, @HttpExchange declarative HTTP clients, RFC 7807 ProblemDetail error handling, GraalVM native image support, AOT compilation, OAuth2 server setup, and Micrometer‑Prometheus monitoring—while providing a practical upgrade roadmap and code samples.

GraalVMJavaSpring
0 likes · 6 min read
Spring 6.0 Core Features and Spring Boot 3.0 Breakthroughs: Virtual Threads, Declarative HTTP Clients, ProblemDetail, GraalVM Native Images, and Monitoring
Architect
Architect
May 25, 2025 · Backend Development

Using Project Loom Virtual Threads in Spring Boot: Setup, Code Samples, and Performance Testing

This article demonstrates how to integrate Project Loom virtual threads into a Spring Boot application, provides the necessary Maven configuration and Java code, runs load tests with JMeter to compare response times against traditional threads, and shows the significant throughput improvements achieved on the same hardware.

JavaProject LoomSpring Boot
0 likes · 9 min read
Using Project Loom Virtual Threads in Spring Boot: Setup, Code Samples, and Performance Testing
Java Tech Enthusiast
Java Tech Enthusiast
May 8, 2025 · Backend Development

Comprehensive Overview of Spring Ecosystem Upgrades: Spring 6 Core Features, Spring Boot 3.0 Breakthroughs, and Migration Roadmap

The article surveys the Spring 6 and Spring Boot 3.0 upgrades—JDK 17 baseline, virtual threads, @HttpExchange client, RFC 7807 ProblemDetail handling, GraalVM native images, Jakarta EE 9+ migration, enhanced auto‑configuration, OAuth2 authorization server, Prometheus‑compatible metrics—and provides a step‑by‑step migration roadmap with practical recommendations for modernizing e‑commerce applications.

Cloud NativeGraalVMJava
0 likes · 7 min read
Comprehensive Overview of Spring Ecosystem Upgrades: Spring 6 Core Features, Spring Boot 3.0 Breakthroughs, and Migration Roadmap
Code Ape Tech Column
Code Ape Tech Column
May 7, 2025 · Backend Development

Detailed Overview of Spring 6.0 Core Features and Spring Boot 3.0 Enhancements

This article provides a comprehensive guide to Spring 6.0’s new baseline JDK 17 requirement, virtual threads, declarative HTTP clients, RFC‑7807 ProblemDetail handling, GraalVM native image support, and Spring Boot 3.0 improvements such as Jakarta EE migration, OAuth2 authorization server, Prometheus monitoring, and practical migration steps for enterprise applications.

GraalVMJavaSpring
0 likes · 8 min read
Detailed Overview of Spring 6.0 Core Features and Spring Boot 3.0 Enhancements
Selected Java Interview Questions
Selected Java Interview Questions
Apr 28, 2025 · Backend Development

Understanding Java Virtual Threads: Basics, Spring Boot Integration, and Performance Comparison

This article introduces Java 21's virtual threads, explains their lightweight and high‑concurrency advantages, demonstrates basic usage and Spring Boot integration with code examples, and compares their performance against traditional threads through practical experiments and additional optimization tips.

Spring Bootbackendconcurrency
0 likes · 7 min read
Understanding Java Virtual Threads: Basics, Spring Boot Integration, and Performance Comparison
Architecture Digest
Architecture Digest
Apr 27, 2025 · Backend Development

Using Java 21 Virtual Threads in Spring Boot: Basics, Performance Comparison, and Best Practices

This article introduces Java 21 virtual threads, explains their lightweight and high‑concurrency advantages, demonstrates basic and delayed creation, shows how to enable them in Spring Boot with minimal configuration, compares performance against traditional threads, and provides additional Java performance optimization tips.

JavaJava 21Spring Boot
0 likes · 6 min read
Using Java 21 Virtual Threads in Spring Boot: Basics, Performance Comparison, and Best Practices
DaTaobao Tech
DaTaobao Tech
Apr 2, 2025 · Backend Development

Understanding Java Virtual Threads: From Traditional Thread Models to Stackful Coroutines

The article traces Java’s concurrency evolution from heavyweight thread‑per‑request and complex reactive models to JDK 21’s virtual threads, which act as stack‑ful coroutines offering lightweight, heap‑allocated threads, full stack traces, and blocking‑I/O compatibility while preserving the familiar thread API.

CoroutinesJDK21Java
0 likes · 24 min read
Understanding Java Virtual Threads: From Traditional Thread Models to Stackful Coroutines
Tencent Cloud Developer
Tencent Cloud Developer
Mar 13, 2025 · Backend Development

Modern Java Features: Lambda, Stream API, Project Loom, Panama, and Valhalla

Modern Java introduces lambda expressions and the Stream API for functional programming, while upcoming projects—Loom’s virtual threads, Panama’s foreign function and memory API, and Valhalla’s value classes and generic specialization—address concurrency, native interop, and performance, dramatically enhancing developer productivity and language capabilities.

JavaLambdaProject Loom
0 likes · 18 min read
Modern Java Features: Lambda, Stream API, Project Loom, Panama, and Valhalla
Architecture Digest
Architecture Digest
Mar 5, 2025 · Backend Development

Understanding Java Virtual Threads and Their Performance Benefits in Spring Boot

This article introduces Java 21's virtual threads, explains their lightweight and high‑concurrency advantages, demonstrates basic and delayed usage with code examples, shows how to enable them in Spring Boot, compares performance against traditional threads, and offers additional Java performance‑tuning techniques.

JavaJava 21Spring Boot
0 likes · 7 min read
Understanding Java Virtual Threads and Their Performance Benefits in Spring Boot
Java High-Performance Architecture
Java High-Performance Architecture
Mar 5, 2025 · Backend Development

Unlock Massive Concurrency: How Java 21 Virtual Threads Supercharge Spring Boot

Java 21’s virtual threads provide lightweight, high‑concurrency execution managed by the JVM, enabling developers to create hundreds of thousands of threads with minimal overhead; this article explains their basics, demonstrates Spring Boot integration, compares performance against traditional threads, and shares additional Java optimization techniques.

JavaSpring Bootconcurrency
0 likes · 8 min read
Unlock Massive Concurrency: How Java 21 Virtual Threads Supercharge Spring Boot
Java Tech Enthusiast
Java Tech Enthusiast
Jan 31, 2025 · Backend Development

Java 21 Virtual Threads: Benefits, Usage, and Performance Comparison

Java 21’s virtual threads provide a lightweight, JVM‑managed alternative to OS threads that enables hundreds of thousands of concurrent tasks, simplifies scheduling, integrates easily into Spring Boot via a preview flag and Tomcat executor, and delivers up to five‑fold speed‑ups and lower latency in high‑load I/O‑intensive applications.

JavaSpring Bootconcurrency
0 likes · 7 min read
Java 21 Virtual Threads: Benefits, Usage, and Performance Comparison
Su San Talks Tech
Su San Talks Tech
Jan 16, 2025 · Backend Development

Boost Java Performance with Virtual Threads: A Hands‑On Guide

This article explains Java 21's virtual threads, their lightweight and auto‑managed nature, demonstrates basic usage and Spring Boot integration, compares performance against traditional threads, and offers additional Java performance tips for high‑concurrency applications.

JavaSpring Bootconcurrency
0 likes · 8 min read
Boost Java Performance with Virtual Threads: A Hands‑On Guide
DaTaobao Tech
DaTaobao Tech
Jan 6, 2025 · Backend Development

Java 21 LTS Features Overview and Practical Guide

This article walks readers through upgrading from Java 11 to the Java 21 LTS by explaining the six‑month release cadence, JEP process, and SDKman setup, then demonstrates practical code examples for twelve new features—including preview Unnamed Classes, String Templates, Scoped Values, Structured Concurrency, Vector API, Virtual Threads, and Generational ZGC—highlighting their motivations, benefits, and production considerations.

Backend DevelopmentJDK LTSJVM
0 likes · 16 min read
Java 21 LTS Features Overview and Practical Guide
JavaEdge
JavaEdge
Dec 31, 2024 · Backend Development

2024 Java Ecosystem Trends: Adoption, AI Integration, and Emerging Foundations

The 2024 Java trend report analyzes JDK adoption rates, AI tooling, the rise of the Commonhaus Foundation, Spring and Jakarta EE evolution, virtual thread adoption, and community insights, offering guidance for technical leaders and developers planning their future investments.

AICommonhausJava
0 likes · 16 min read
2024 Java Ecosystem Trends: Adoption, AI Integration, and Emerging Foundations
Architecture Digest
Architecture Digest
Dec 26, 2024 · Backend Development

Understanding Java 21 Virtual Threads: Basics, Spring Boot Integration, and Performance Comparison

This article introduces Java 21 virtual threads, explains their lightweight, high‑concurrency and automatic management advantages, demonstrates basic and delayed usage with code examples, shows how to enable them in Spring Boot, and compares their performance against traditional threads in various scenarios.

JavaJava 21Spring Boot
0 likes · 7 min read
Understanding Java 21 Virtual Threads: Basics, Spring Boot Integration, and Performance Comparison
Architecture Digest
Architecture Digest
Dec 10, 2024 · Backend Development

Understanding Java Virtual Threads and Their Use in Spring Boot

This article explains Java 21's virtual threads, their lightweight and high‑concurrency advantages, demonstrates basic creation and Spring Boot integration, compares performance against traditional threads, and offers additional Java performance optimization techniques.

JavaJava 21Spring Boot
0 likes · 7 min read
Understanding Java Virtual Threads and Their Use in Spring Boot
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Nov 11, 2024 · Backend Development

Master Spring Boot 3 Task Scheduling: Interfaces, Annotations, Cron & Virtual Threads

This article explains how to use Spring Boot 3's TaskScheduler API, @Scheduled annotations, cron expressions, macro shortcuts, reactive support, virtual threads, and custom scheduling configuration, providing code examples and configuration tips for reliable backend task execution.

Backend DevelopmentSpring BootTask scheduling
0 likes · 8 min read
Master Spring Boot 3 Task Scheduling: Interfaces, Annotations, Cron & Virtual Threads
Alibaba Cloud Developer
Alibaba Cloud Developer
Sep 18, 2024 · Backend Development

Unlock Massive Concurrency with Java Virtual Threads: A Deep Dive

This article explores Java virtual threads introduced in JDK 21, detailing their architecture, implementation, practical usage with Thread and Executors APIs, performance comparisons against platform threads, best‑practice guidelines, and benchmark results demonstrating superior throughput for high‑concurrency server applications.

JDK21Javaconcurrency
0 likes · 24 min read
Unlock Massive Concurrency with Java Virtual Threads: A Deep Dive
DaTaobao Tech
DaTaobao Tech
Aug 28, 2024 · Backend Development

Understanding Java Virtual Threads: Principles, Implementation, and Performance

Java virtual threads, introduced in JDK 21, decouple Java threads from OS threads by using continuations and a ForkJoinPool scheduler, allowing millions of cheap, blocking‑friendly threads that boost throughput and simplify concurrent code compared to traditional platform threads or reactive frameworks, as demonstrated by performance benchmarks.

JDK21Javavirtual-threads
0 likes · 23 min read
Understanding Java Virtual Threads: Principles, Implementation, and Performance
IT Xianyu
IT Xianyu
Aug 23, 2024 · Backend Development

Using Java Virtual Threads in Spring Boot: Configuration and Performance Comparison

The article explains Java's virtual threads introduced in Java 19, compares them with traditional threads, and demonstrates how to configure Spring Boot to use virtual threads, including code samples and performance benchmarks that show dramatic latency reductions in both async services and HTTP requests.

JavaSpring Bootvirtual-threads
0 likes · 6 min read
Using Java Virtual Threads in Spring Boot: Configuration and Performance Comparison
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 5, 2024 · Backend Development

Unlock Massive Concurrency: How Java Virtual Threads Transform Backend Development

This article explains Java virtual threads, contrasting them with platform threads, and shows how to create, schedule, and use them effectively with Thread.Builder and Executors to achieve high‑throughput, low‑latency server applications while avoiding common pitfalls like pooling and pinning.

Backend DevelopmentJDK21concurrency
0 likes · 14 min read
Unlock Massive Concurrency: How Java Virtual Threads Transform Backend Development
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
May 10, 2024 · Backend Development

Master Spring Boot 3 Virtual Threads: Prevent Daemon Issues & Keep Apps Alive

This guide explains how Spring Boot 3.2+ leverages JDK 21 virtual threads, demonstrates common pitfalls in non‑web applications—especially daemon thread termination—and shows how to enable keep‑alive configuration to ensure your tasks keep running, complete with code examples and performance insights.

Spring Bootconcurrencykeepalive
0 likes · 9 min read
Master Spring Boot 3 Virtual Threads: Prevent Daemon Issues & Keep Apps Alive
DaTaobao Tech
DaTaobao Tech
Mar 20, 2024 · Backend Development

Understanding Java Stream Gather API and the mapConcurrent Operator

The article explains Java 22’s new Stream Gather API, which extends the traditional Stream model with custom Gatherers that can emit zero‑to‑many elements, enabling stateful, parallel operations such as a concurrency‑controlled mapConcurrent operator built on virtual threads, and compares it to Reactor‑core and Pekko‑Stream.

Functional ProgrammingGather APIJava
0 likes · 14 min read
Understanding Java Stream Gather API and the mapConcurrent Operator
Programmer DD
Programmer DD
Jan 18, 2024 · Backend Development

Why Virtual Threads Lag Behind WebFlux in Spring Boot MySQL Performance

This article examines a performance comparison of Spring Boot applications using physical threads, Java virtual threads, and WebFlux for JWT verification with MySQL, detailing test setup, code examples, benchmark results across various concurrency levels, and concluding that virtual threads perform worst due to MySQL driver incompatibility.

Spring BootWebFluxmysql
0 likes · 9 min read
Why Virtual Threads Lag Behind WebFlux in Spring Boot MySQL Performance
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jan 16, 2024 · Backend Development

Spring 6: HTTP Interfaces, RestClient, i18n ProblemDetail, Virtual Threads

This guide walks through Spring 6’s new capabilities—including Java 17 baseline, Jakarta namespace migration, HTTP interface proxies with @HttpExchange, WebClient integration via JDK HttpClient, internationalized ProblemDetail handling, the RestClient API, and executing asynchronous tasks on virtual threads—all demonstrated with concise code examples.

HTTPJavaProblemDetail
0 likes · 7 min read
Spring 6: HTTP Interfaces, RestClient, i18n ProblemDetail, Virtual Threads
Programmer DD
Programmer DD
Jan 5, 2024 · Backend Development

How Fast Are Virtual Threads in Spring Boot 3.2 for Static File Servers?

This article evaluates the performance of Spring Boot 3.2's virtual threads when serving static files, comparing them with traditional platform threads across various concurrency levels, and concludes that platform threads slightly outperform virtual threads in this I/O‑bound scenario while suggesting better use cases for database‑driven workloads.

Java 21Spring BootStatic File Server
0 likes · 12 min read
How Fast Are Virtual Threads in Spring Boot 3.2 for Static File Servers?
FunTester
FunTester
Jan 3, 2024 · Backend Development

Design and Implementation of a Java Virtual Thread Asynchronous Task Framework

This article introduces a Java virtual‑thread based asynchronous task framework, detailing its design constraints, a thread‑safe task queue, daemon thread management, and overloaded execute methods for Runnable and Groovy Closure, along with code examples and performance testing considerations.

Daemon ThreadJavaTask Queue
0 likes · 9 min read
Design and Implementation of a Java Virtual Thread Asynchronous Task Framework
Java Backend Technology
Java Backend Technology
Dec 26, 2023 · Backend Development

Exploring Spring Boot 3.2: Java 21, Virtual Threads, and GraalVM Native Images

Spring Boot 3.2 now fully supports Java 21, Project Loom virtual threads, and GraalVM native images, and this guide walks through installing Java 21‑GraalVM, configuring virtual threads, building sample controllers, async and scheduled tasks, and creating a native executable to achieve faster startup and lower memory usage.

Backend DevelopmentGraalVMJava 21
0 likes · 9 min read
Exploring Spring Boot 3.2: Java 21, Virtual Threads, and GraalVM Native Images
Bitu Technology
Bitu Technology
Dec 8, 2023 · Backend Development

JDK Virtual Threads: The Ultimate Solution for Java Concurrency – Insights from the Scala & Java Meetup

The article recaps a Scala & Java meetup where experts discussed the challenges of traditional Java threading, introduced JDK virtual threads as a low‑overhead concurrency solution, examined their benefits and limitations, and explored the impact of virtual threads on Scala and reactive programming.

JDKReactive Programmingvirtual-threads
0 likes · 9 min read
JDK Virtual Threads: The Ultimate Solution for Java Concurrency – Insights from the Scala & Java Meetup
JavaEdge
JavaEdge
Dec 7, 2023 · Backend Development

Why Java’s Blocking Model Is a Bottleneck and How Virtual Threads Solve It

Java’s traditional synchronous blocking model wastes thread resources during I/O, leading to scalability limits, while asynchronous, reactive, and especially Java 21’s virtual threads offer non‑blocking execution paths that improve performance and simplify development without complex reactive pipelines.

JavaReactive Programmingasync
0 likes · 11 min read
Why Java’s Blocking Model Is a Bottleneck and How Virtual Threads Solve It
Bitu Technology
Bitu Technology
Nov 30, 2023 · Backend Development

Virtual Threads: The Ultimate JDK Concurrency Solution – Highlights from the Scala & Java Meetup

The article recaps a Scala & Java meetup where experts discussed Java virtual threads as a breakthrough for JDK concurrency, examined their advantages over traditional threads, addressed limitations, explored their impact on Scala and other JVM languages, and included audience Q&A and community announcements.

Backend DevelopmentJDKvirtual-threads
0 likes · 9 min read
Virtual Threads: The Ultimate JDK Concurrency Solution – Highlights from the Scala & Java Meetup
Architecture Digest
Architecture Digest
Nov 29, 2023 · Backend Development

Exploring Spring Boot 3.2 with Java 21, GraalVM Native Images, and Virtual Threads

This article demonstrates how Spring Boot 3.2 fully supports Java 21, Project Loom virtual threads, and GraalVM native images, providing step‑by‑step instructions, configuration details, and runnable code examples that showcase building, running, and profiling a Spring Boot application with these modern technologies.

Backend DevelopmentGraalVMJava 21
0 likes · 8 min read
Exploring Spring Boot 3.2 with Java 21, GraalVM Native Images, and Virtual Threads
Programmer DD
Programmer DD
Nov 24, 2023 · Backend Development

What’s New in Spring Boot 3.2? Explore Java 21 Features and Virtual Threads

Spring Boot 3.2, released shortly after Java 21, brings a host of enhancements such as virtual thread support, CRaC checkpoint restore, SSL bundle reloading, improved observability, new RestClient and JdbcClient, Jetty 12, Pulsar, Kafka and RabbitMQ SSL, redesigned nested JAR handling, Docker image build upgrades, and a comprehensive video walkthrough by Josh Long.

Backend DevelopmentDockerJava 21
0 likes · 7 min read
What’s New in Spring Boot 3.2? Explore Java 21 Features and Virtual Threads