Your Virtual Threads Are Leaking: Why ScopedValue is the Only Way Forward. If you're spinning up millions of Virtual Threads but still clinging to ThreadLocal, you're building a memory bomb. Java 21 changed the game, and if you haven't migrated to ScopedValue yet, you're missing the actual point of lightweight concurrency. The Scalability Trap: Treating Virtual Threads like Platform Threads. Thinking millions of ThreadLocal maps won't wreck your heap is a rookie mistake; the per-thread overhead adds up fast when you scale to 100k+ concurrent tasks. The Mutability Nightmare: Using ThreadLocal.set() creates unpredictable side effects in deep call stacks. In a world of massive concurrency, mutable global state is a debugging death sentence. Manual Cleanup Failures: Relying on try-finally to .remove() locals. It inevitably fails during unhandled exceptions or complex async handoffs, leading to "ghost" data bleeding between requests. Shift from long-lived, mutable thread-bound state to scoped, immutable context propagation. Use ScopedValue.where(...) to define strict, readable boundaries for your data (like Tenant IDs or User principals). Embrace Structured Concurrency: use StructuredTaskScope to ensure context propagates automatically and safely to child threads. Treat context as strictly immutable; if you need to change a value, you re-bind it in a nested scope rather than mutating the current one. Optimize for memory: ScopedValue is designed to be lightweight, often stored in a single internal array rather than a complex hash map. private final static ScopedValue TENANT_ID = ScopedValue.newInstance(); public void serveRequest(String tenant, Runnable logic) { // Context is bound to this scope and its children only ScopedValue.where(TENANT_ID, tenant).run(() -> { performBusinessLogic(); }); // Outside this block, TENANT_ID is automatically cleared } void performBusinessLogic() { // O(1) access, no risk of memory leaks, completely immutable String currentTenant = TENANT_ID.get(); System.out.println("Working for: " + currentTenant); } Memory Efficiency: ScopedValue eliminates the heavy ThreadLocalMap overhead, making it the only viable choice for high-density Virtual Thread architectures. Safety by Default: Immutability isn't a limitation; it's a feature that prevents "spooky action at a distance" across your call stack. Structured Inheritance: Unlike InheritableThreadLocal, which performs expensive data copying, ScopedValue shares data efficiently with child threads within a StructuredTaskScope. Want to go deeper? javalld.com — machine coding interview problems with working Java code and full execution traces.