DEV Community: Machine coding Master

Java & AI: What Developers Need to Know

Machine coding Master — Sat, 06 Jun 2026 06:08:21 +0000

Stop Letting Claude Write Java 8: How to Force JDK 26 Idioms in Your .cursorrules

If you are still letting Claude or GPT-4o spit out legacy Java 8/11 boilerplate in 2026, you are wasting your subscription. Your AI assistant doesn't know you've upgraded to JDK 26 unless you force its hand with strict, opinionated workspace rules.

Why Most Developers Get This Wrong

Relying on default LLM system prompts: Out-of-the-box models default to the most common internet data, meaning you get deprecated ThreadLocal patterns and bloated CompletableFuture chains.
Ignoring Virtual Thread safety: AI tools love generating heavy synchronized blocks and thread-local caches, which pin carrier threads and destroy virtual thread throughput.
Assuming the AI knows your stack: Without explicit workspace boundaries, the model will continuously hallucinate mixed-version code, combining JDK 21 record patterns with ancient Apache Commons utilities.

The Right Way

To get clean, performant, and modern Java code, you must hardcode JDK 26 idioms directly into your workspace .cursorrules or .claudecode configurations.

Ban Legacy Concurrency: Explicitly forbid ThreadLocal and ExecutorService in favor of JEP 480 Structured Concurrency and Scoped Values.
Mandate Virtual Thread Safety: Rule-bind the AI to avoid locking carrier threads by replacing synchronized with ReentrantLock.
Enforce Pattern Matching & Records: Demand the use of record patterns, sealed interfaces, and modern switch expressions for all data modeling.

Show Me The Code (or Example)

Add this snippet to your .cursorrules or .claudecode file in your repository root:

# JDK 26 Concurrency Rules
- NEVER use ThreadLocal. ALWAYS use ScopedValue.
- NEVER use CompletableFuture for task orchestration. Use JEP 480 StructuredTaskScope.
- Avoid 'synchronized' blocks to prevent carrier thread pinning; use ReentrantLock.

# Example of Expected Concurrency Pattern:
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Subtask<String> task = scope.fork(() -> fetchUserData());
    scope.join().throwIfFailed();
    return task.get();
}

Key Takeaways

LLMs are historically biased: Without a .cursorrules file, your AI assistant will default to 2014-era Java boilerplate.
Virtual threads demand new patterns: Legacy thread-safety patterns kill virtual thread performance—your prompt configuration is your first line of defense.
Automate your standards: Commit your AI configuration files to git so your entire team instantly generates optimized, modern JDK 26 code.

If you're prepping for interviews, I've been building javalld.com — real machine coding problems with full execution traces.

---JSON
{"title": "Stop Letting Claude Write Java 8: How to Force JDK 26 Idioms in Your .cursorrules", "tags": ["java", "productivity", "concurrency", "ai"]}
---END---

Stop Leaking Trace Context: How to Migrate OpenTelemetry to JDK 26 Scoped Values

Machine coding Master — Fri, 05 Jun 2026 06:50:19 +0000

Stop Leaking Trace Context: How to Migrate OpenTelemetry to JDK 26 Scoped Values

If you are still relying on traditional ThreadLocal storage for OpenTelemetry context propagation under JDK 26's virtual threads, you are sitting on a production time bomb. Millions of concurrent virtual threads will quickly turn your heap into a graveyard of leaked trace contexts and bloated memory overhead.

If you're prepping for interviews, I've been building javalld.com — real machine coding problems with full execution traces.

Why Most Developers Get This Wrong

Defaulting to ThreadLocal: Assuming the default OpenTelemetry ThreadLocal storage works fine with virtual threads, ignoring the heavy heap footprint and context drift when threads are unmounted and rescheduled.
Ignoring Context Leakage: Forgetting that ThreadLocal values persist unless explicitly removed, causing trace data to bleed into unrelated tasks on shared carrier threads.
Manual Propagation Mess: Manually passing Span objects down the call stack instead of leveraging JDK 26's native scoped value propagation.

The Right Way

The clean solution is to bind OpenTelemetry's ContextStorage directly to JEP 487 Scoped Values to enforce immutable, automatic, and thread-safe context propagation across virtual threads and structured concurrency boundaries.

Implement Custom ContextStorage: Create an OTel ContextStorage implementation backed by a static ScopedValue<Context>.
Enforce Immutability: Leverage the immutable nature of ScopedValue to prevent downstream child threads from accidentally mutating the parent's tracing context.
Leverage Structured Concurrency: Use StructuredTaskScope which automatically inherits the scoped trace context without manual boilerplate.

Show Me The Code

Here is how to run a span using JDK 26 ScopedValue for zero-leak, zero-overhead propagation:

public class ScopedTraceRunner {
    private static final ScopedValue<Span> ACTIVE_SPAN = ScopedValue.newInstance();

    public void execute(Span span, Runnable task) {
        // Bind span immutably to the current scope
        ScopedValue.where(ACTIVE_SPAN, span).run(() -> {
            try (var scope = span.makeCurrent()) {
                task.run(); 
            } // Span scope closes cleanly here
        });
    }
}

Key Takeaways

Zero Memory Overhead: ScopedValue is optimized for millions of virtual threads, avoiding the heavy thread-local map overhead.
Strict Scope Lifecycle: Contexts are automatically unbound when the execution block exits, completely eliminating trace leakage.
Native Structured Concurrency: Child threads spawned inside a StructuredTaskScope automatically inherit scoped trace contexts without manual configuration.

Stop Blocking Virtual Threads: Building Asynchronous Human-in-the-Loop AI Agents with Spring AI

Machine coding Master — Thu, 04 Jun 2026 07:08:47 +0000

Stop Blocking Virtual Threads: Building Asynchronous Human-in-the-Loop AI Agents with Spring AI

In 2026, letting autonomous AI agents execute high-risk enterprise tools without human oversight is a production liability, but blocking platform threads—or even Project Loom’s virtual threads—for hours waiting for a manager's Slack approval is absolute architectural malpractice. We must transition from synchronous execution loops to stateless, event-driven agent hydration where the LLM's reasoning state is serialized and persisted during human-in-the-loop (HITL) interrupts.

Why Most Developers Get This Wrong

Virtual Thread Abuse: Thinking Virtual Threads (VirtualThreadExecutor) solve the wait problem—they do not; holding resources open for a 4-hour human coffee break destroys system scalability and ruins connection pools.
State-in-Memory Antipattern: Storing the active ReAct loop state (like active ChatMemory or agent context) in local heap memory, making your system highly vulnerable to redeployments and node failures.
Polled-Waiting Loops: Using CompletableFuture or busy-waiting database polling loops to check if a human has clicked "Approve" on an external UI.

The Right Way

The clean solution is to serialize the agent's execution state—the ReAct loop token history, tool call IDs, and pending variables—to a persistent store, terminate the active thread immediately, and hydrate a brand-new agent instance when the approval webhook fires.

Explicit Interrupt Exceptions: Throw a specialized AgentSuspensionException containing the serialized stateId and tool execution metadata when a high-risk tool is triggered.
State Hydration: Use Spring AI's ChatClient with a custom Redis-backed ChatMemory implementation that supports snapshotting at specific message indices.
Asynchronous Resumption: Expose a stateless REST endpoint /api/v1/agent/resume that accepts the human decision, merges it into the serialized history as a ToolResponseMessage, and triggers the next step of the ReAct loop.

Show Me The Code

@PostMapping("/agent/resume")
public ResponseEntity<String> resumeAgent(@RequestBody ApprovalResponse approval) {
    // 1. Retrieve serialized chat history (ReAct state) from Redis
    List<Message> history = stateRepository.findById(approval.stateId());

    // 2. Inject the human's decision as if it were the tool's output
    String toolOutput = approval.approved() ? "Approved: " + approval.notes() : "Rejected by human";
    history.add(new ToolResponseMessage(approval.toolCallId(), toolOutput));

    // 3. Hydrate the agent and resume execution without blocking threads
    ChatResponse response = chatClient.prompt()
        .messages(history)
        .call()
        .chatResponse();

    return ResponseEntity.ok(response.getResult().getOutput().getContent());
}

Key Takeaways

Never block on humans: Treat human approvals as asynchronous, event-driven inputs, not long-lived synchronous I/O operations.
Serialize the prompt history: Store the exact LLM prompt/response state to Redis or Postgres to ensure your agents are completely stateless between tool calls.
Leverage Spring AI's modularity: Use custom ChatMemory adapters to dynamically hydrate and dehydrate context windows on demand.

Heads up: if you want to see these patterns applied to real interview problems, javalld.com has full machine coding solutions with traces.

Java LLD: Designing a Robust Vehicle Rental System

Machine coding Master — Wed, 03 Jun 2026 07:24:21 +0000

Java LLD: Designing a Robust Vehicle Rental System

Designing a Vehicle Rental System is a classic Low-Level Design (LLD) question frequently asked at companies like Uber, Grab, and Amazon. While the requirements seem simple on the surface, candidates often struggle to handle complex state transitions and dynamic pricing models cleanly under pressure.

The Mistake Most Candidates Make

Monolithic State Management: Using massive, nested if-else or switch-case blocks inside the Vehicle class to handle state transitions, leading to spaghetti code.
Hardcoded Pricing Logic: Embedding billing and pricing calculations directly inside the reservation flow, making it incredibly difficult to support dynamic or holiday rates.
Weak State Encapsulation: Allowing illegal state transitions (such as moving a vehicle directly from Reserved to UnderMaintenance) due to scattered validation logic.

The Right Approach

Core mental model: Model the vehicle's lifecycle as a self-contained state machine using the State Pattern, delegating transition rules directly to individual state objects.
Key entities/classes: Vehicle, VehicleState (interface), AvailableState, ReservedState, RentedState, UnderMaintenanceState, PricingStrategy, VehicleFactory.
Why it beats the naive approach: It strictly enforces the Open-Closed Principle, allowing you to add new states (like Damaged or InTransit) or billing rules without modifying existing classes.

I built javalld.com while prepping for senior roles — complete LLD problems with execution traces, not just theory.

The Key Insight (Code)

Here is how you cleanly reject illegal transitions at the state level using the State Pattern:

public interface VehicleState {
    void reserve(Vehicle vehicle);
    void rent(Vehicle vehicle);
}

public class RentedState implements VehicleState {
    @Override
    public void reserve(Vehicle vehicle) {
        throw new IllegalStateException("Cannot reserve a rented vehicle!");
    }

    @Override
    public void rent(Vehicle vehicle) {
        throw new IllegalStateException("Vehicle is already rented!");
    }
}

Key Takeaways

State Pattern Enforces Constraints: Moving transition rules into dedicated state classes ensures illegal actions throw exceptions naturally, eliminating conditional clutter.
Strategy Pattern Decouples Billing: Separating pricing algorithms from the vehicle entity allows you to dynamically swap rates (e.g., hourly, weekly, or surge pricing).
Factory Pattern Centralizes Creation: Using a factory to instantiate different vehicle types (e.g., Cars, Bikes) keeps your client code decoupled from concrete implementations.

Full working implementation with execution trace available at https://javalld.com/problems/vehicle-rental

Java & AI: What Developers Need to Know

Machine coding Master — Tue, 02 Jun 2026 07:11:09 +0000

Stop Parsing Untrusted LLM JSON: Enforce GPT-5 Strict Schemas with Java 26 Class-File API

In 2026, relying on Jackson to parse loose, non-deterministic JSON from LLMs is architectural malpractice. With GPT-5 offering mathematically guaranteed schema adherence, we can now use the JDK 26 Class-File API (JEP 466) to dynamically extract bytecode schemas at startup, bypassing reflection entirely.

Why Most Developers Get This Wrong

Failing gracefully is still failing: Developers are still writing defensive try-catch blocks around Jackson ObjectMapper to handle malformed JSON, instead of forcing the model to adhere to a strict schema at the API boundary.
Reflection overhead: Using traditional reflection-based JSON schema generators at runtime introduces massive cold-start latency and CPU overhead in high-throughput microservices.
Ignoring GPT-5's Strict Mode: Passing raw prompt instructions like "return JSON" instead of utilizing the response_format JSON Schema constraint, which guarantees 100% grammar-based compliance.

The Right Way

Compile your target Java Record into a lightweight schema payload using the JDK 26 Class-File API, and feed it directly to GPT-5 to guarantee type-safe responses.

Zero-Reflection Validation: Use java.lang.classfile.ClassFile to parse your compiled Java Records at startup to build your JSON schema.
Enforce Strict Mode: Always set response_format: { type: "json_schema", json_schema: { strict: true, ... } } in your GPT-5 API calls.
Type-Safe Mapping: Map the mathematically guaranteed LLM response directly to your record components, eliminating runtime parsing errors.

Shameless plug: javalld.com has full LLD implementations with step-by-step execution traces — free to use while prepping.

Show Me The Code

Here is how you parse a Java Record using the JDK 26 Class-File API to build a strict GPT-5 schema payload without reflection:

// Parse bytecode natively using JDK 26 Class-File API (JEP 466)
byte[] bytes = ClassLoader.getSystemResourceAsStream("com/app/User.class").readAllBytes();
ClassModel model = ClassFile.of().parse(bytes);

var schemaProperties = model.methods().stream()
    .filter(m -> m.flags().has(AccessFlag.PUBLIC) && !m.methodName().stringValue().equals("<init>"))
    .collect(Collectors.toMap(
        m -> m.methodName().stringValue(),
        m -> Map.of("type", mapDescriptorToType(m.methodType().stringValue()))
    ));

// Send strictly structured payload to GPT-5
var gpt5Request = Map.of(
    "model", "gpt-5",
    "response_format", Map.of(
        "type", "json_schema",
        "json_schema", Map.of("name", "user_schema", "strict", true, "schema", 
            Map.of("type", "object", "properties", schemaProperties, "required", schemaProperties.keySet().stream().toList(), "additionalProperties", false))
    )
);

Key Takeaways

Stop guessing: GPT-5's strict schema enforcement guarantees 100% structural accuracy, making runtime JSON parsing errors a thing of the past.
Embrace JEP 466: The JDK 26 Class-File API replaces outdated ASM/ByteBuddy hacks, allowing you to inspect and generate bytecode natively.
Performance is a feature: Eliminating reflection in your LLM-to-Java pipeline drops startup and ingestion latency by up to 40% under heavy enterprise loads.

---JSON
{"title": "Stop Parsing Untrusted LLM JSON: Enforce GPT-5 Strict Schemas with Java 26 Class-File API", "tags": ["java", "ai", "llm", "systemdesign"]}
---END---

Stop Burning Cash on Long-Context RAG: Ephemeral Prompt Caching with Spring AI and JTokkit

Machine coding Master — Sun, 31 May 2026 06:41:33 +0000

Stop Burning Cash on Long-Context RAG: Ephemeral Prompt Caching with Spring AI and JTokkit

If your enterprise RAG pipeline is processing megabytes of legal documents or codebase context, you are likely burning thousands of dollars daily on redundant input tokens. Ephemeral prompt caching can slash these LLM costs by up to 90%, but only if you align your token boundaries perfectly inside your Java backend.

Why Most Developers Get This Wrong

Blindly trusting Spring AI's defaults: Relying on default ChatClient configurations without verifying token boundaries, causing cache misses on every slight prompt variation.
Ignoring the 1024-token floor: Underestimating the strict minimum boundary requirements of providers like Anthropic or OpenAI, leading to zero cache hits for smaller context chunks.
Dynamic pollution: Appending dynamic user queries before the static system context, which instantly invalidates the entire downstream prefix cache.

The Right Way

To guarantee a 90% cache hit rate, you must isolate your heavy, immutable context at the front of the prompt and programmatically verify token boundaries using JTokkit before hitting the LLM API.

Strict Prefix Ordering: Place your massive PDF knowledge bases or database schemas at the absolute beginning of the prompt sequence.
Programmatic Verification: Use JTokkit's EncodingRegistry to calculate the exact token count, ensuring your cached prefix meets the provider's minimum threshold (e.g., 1024 tokens for Claude 3.5).
Spring AI Advisor Decoupling: Implement a custom AroundAdvisor to intercept the chat request and inject vendor-specific caching headers dynamically.

Show Me The Code (or Example)

// Verify 1024-token minimum with JTokkit before enabling Ephemeral Caching
Encoding enc = LazyEncodingRegistry.getRegistry().getEncoding(EncodingType.CL100K_BASE);
if (enc.countTokens(systemContext) >= 1024) {
    return chatClient.prompt()
        .advisors(new EphemeralCacheAdvisor()) // Custom Spring AI Advisor injecting "type": "ephemeral"
        .system(sp -> sp.text(systemContext))
        .user(userQuery)
        .call()
        .content();
}

Key Takeaways

Prefix is King: Cacheable content must live strictly at the start of your payload; a single character change before it invalidates the cache.
Assert, Don't Guess: Use JTokkit to programmatically assert the 1024-token minimum before committing to cache headers.
Clean Architecture: Keep your business logic clean by delegating caching headers to custom Spring AI ChatClient Advisors.

Heads up: if you want to see these patterns applied to real interview problems, javalld.com has full machine coding solutions with traces.

JDK 26 Pitfalls: Why CPU-Bound Tasks are Killing Your Virtual Threads

Machine coding Master — Sat, 30 May 2026 06:01:53 +0000

JDK 26 Pitfalls: Why CPU-Bound Tasks are Killing Your Virtual Threads

In JDK 26, teams are blindly migrating entire microservices to virtual threads and wondering why their p99 latency is suddenly spiking into the seconds. The culprit is carrier thread starvation: developers are treating lightweight virtual threads like silver bullets, forgetting that cooperative scheduling requires yield points that CPU-bound tasks simply do not have.

Why Most Developers Get This Wrong

Treating virtual threads as "faster" threads rather than "cheaper to block" threads. This leads to CPU-heavy operations (like JWT validation or heavy JSON parsing) being scheduled on the default ForkJoinPool carrier pool, which is sized strictly to the number of available CPU cores.
Assuming the JVM will preemptively time-slice virtual threads. In reality, Project Loom relies on cooperative scheduling, meaning a thread only yields during blocking I/O (e.g., socket reads, database queries, or explicit locks).
Running un-yieldable CPU tasks that monopolize carrier threads, starving the other thousands of virtual threads waiting in the scheduler queue and completely halting the application's throughput.

The Right Way

Keep virtual threads strictly for I/O-bound operations and offload CPU-bound computations to a dedicated, sized platform thread pool.

Isolate CPU-heavy tasks (e.g., BCrypt hashing, Jackson serialization of massive payloads, or complex cryptography) using a traditional ThreadPoolExecutor sized strictly to the machine's physical cores.
Bridge the gap using CompletableFuture.supplyAsync(), allowing the calling virtual thread to park cleanly and yield its carrier thread while the platform thread handles the heavy lifting.
Actively monitor carrier thread pinning and starvation using JDK Flight Recorder (JFR) with the jdk.VirtualThreadPinned event to identify blocking native calls or synchronized blocks.

Shameless plug: javalld.com has full LLD implementations with step-by-step execution traces — free to use while prepping.

Show Me The Code (or Example)

// Inside a Virtual Thread handler
public Response handleRequest(Request req) {
    // I/O bound: Fetch from DB (Virtual thread yields here)
    var user = db.findUser(req.userId()); 

    // CPU bound: Offload to prevent Carrier Thread Starvation
    var token = CompletableFuture.supplyAsync(
        () -> jwtService.generateToken(user), CPU_PLATFORM_POOL
    ).join(); // Virtual thread yields cleanly while platform thread works

    return new Response(token);
}

Key Takeaways

Virtual threads are designed for waiting, not for burning CPU cycles.
No yield point means carrier thread hijacking; keep ForkJoinPool free.
Always isolate CPU-bound tasks in a dedicated, sized platform ThreadPoolExecutor.

Java LLD: Designing a Thread-Safe Parking Lot with Strategy Pattern

Machine coding Master — Fri, 29 May 2026 06:41:47 +0000

Java LLD: Designing a Thread-Safe Parking Lot with Strategy Pattern

Designing a parking lot is a staple of Java LLD and machine coding interviews, yet most candidates fail to write production-grade code. As an ex-FAANG interviewer, I've seen countless designs fall apart under concurrent traffic or when asked to support multiple slot allocation algorithms.

If you're prepping for interviews, I've been building javalld.com — real machine coding problems with full execution traces.

The Mistake Most Candidates Make

Monolithic locking on the entire ParkingLot class: Using a global synchronized keyword on the entry method, which serializes all gate entries and destroys system throughput.
Hardcoding slot-finding logic: Mixing spatial layout algorithms (like nearest-to-entrance or smallest-available-fit) directly inside the ParkingLot or Gate classes, violating the Open-Closed Principle.
Thread-safety as an afterthought: Relying on raw List<Slot> iterations without synchronization, causing race conditions where multiple cars are assigned to the exact same physical slot.

The Right Approach

Core mental model: Decouple capacity management from slot selection by using a Semaphore for gate-keeping and the Strategy Pattern for thread-safe slot allocation.
Key entities: ParkingLot, Gate, Slot, Vehicle, ParkingStrategy (SmallestFitStrategy, NearestEntranceStrategy), and StrategyFactory.
Why it beats the naive approach: It isolates concurrency concerns (preventing overbooking) from business rules (how we choose a slot), making the system highly performant and easily extensible.

The Key Insight (Code)

public class EntryGate {
    private final Semaphore semaphore;
    private final ParkingStrategy strategy;

    public EntryGate(int capacity, ParkingStrategy strategy) {
        this.semaphore = new Semaphore(capacity);
        this.strategy = strategy;
    }

    public synchronized Ticket park(Vehicle vehicle) {
        if (!semaphore.tryAcquire()) throw new ParkingFullException();
        Slot slot = strategy.allocateSlot(vehicle);
        slot.occupy(vehicle);
        return new Ticket(vehicle, slot);
    }
}

Key Takeaways

Throttle Early with Semaphores: Use a Semaphore at the gate level to reject incoming cars instantly when the lot is full, avoiding expensive database or memory lock lookups.
Strategy Pattern for Allocation: Encapsulate slot-finding algorithms in a ParkingStrategy interface, allowing the system to switch behaviors dynamically at runtime.
Factory Pattern for Instantiation: Leverage a StrategyFactory to cleanly instantiate the correct allocation strategy based on the parking lot's operating mode.

Full working implementation with execution trace available at https://javalld.com/problems/parking-lot

Java & AI: What Developers Need to Know

Machine coding Master — Thu, 28 May 2026 06:37:58 +0000

Java LLD: High-Concurrency Ticket Booking System (BookMyShow)

Designing BookMyShow is a classic LLD interview favorite because it tests your ability to handle high concurrency without sacrificing data consistency. If you cannot explain how to prevent two users from booking the exact same seat simultaneously under heavy load, your system design interview is over.

The Mistake Most Candidates Make

Global Database Locks: Using heavy database-level row locks (SELECT ... FOR UPDATE) which drastically reduces throughput during peak ticket sales.
Linear Seat Scanning: Utilizing basic arrays or lists to search for contiguous seat allocations, resulting in slow $O(N)$ query times.
Naïve Synchronization: Synchronizing the entire booking method block, which bottlenecks the entire system and prevents concurrent bookings across different theaters.

The Right Approach

Core mental model: Isolate seat contention per show using in-memory semaphores, while managing contiguous seat boundaries using an Interval Tree.
Key entities/classes: Show, Seat, ShowSeatManager, IntervalTree, Booking.
Why it beats the naive approach: It localizes lock contention to individual shows instead of the entire database, enabling millions of concurrent users to book different shows simultaneously.

Shameless plug: javalld.com has full LLD implementations with step-by-step execution traces — free to use while prepping.

The Key Insight (Code)

public class ShowSeatManager {
    private final Semaphore showLock = new Semaphore(1); // Isolate lock per show
    private final IntervalTree bookedSeats = new IntervalTree(); 

    public boolean reserveSeats(int start, int end) {
        if (!showLock.tryAcquire()) return false; // Fail fast under heavy load
        try {
            if (bookedSeats.hasOverlap(start, end)) {
                return false; // Already booked
            }
            bookedSeats.insert(start, end);
            return true;
        } finally {
            showLock.release();
        }
    }
}

Key Takeaways

Thread Confinement via Semaphores: Use a dedicated Semaphore per show to localize concurrency, ensuring that high demand for a blockbuster movie doesn't block bookings for other shows.
Interval Tree for Range Queries: Optimize contiguous seat selection; checking if a range of seats (e.g., seats 10 to 15) is available drops from $O(N)$ to $O(\log N)$ complexity.
Optimistic Locking Safety Net: Pair your in-memory locks with database optimistic locking (@Version) as a final line of defense to guarantee zero double-bookings.

Full working implementation with execution trace available at https://javalld.com/problems/bookmyshow

---JSON
{
"title": "Java LLD: High-Concurrency Ticket Booking System (BookMyShow)",
"tags": ["java", "design", "concurrency", "systemdesign"]
}
---END---

Why Your eBPF Profiler Lies to You About Java Virtual Threads

Machine coding Master — Wed, 27 May 2026 06:47:01 +0000

Why Your eBPF Profiler Lies to You About Java Virtual Threads

In 2026, virtual threads are the default concurrency model in Java, but your production profiling is likely still blind to what is actually happening at the OS level. Traditional eBPF profilers see carrier threads (ForkJoinPool-1-worker-*), completely missing the ephemeral virtual threads (VirtualThread) mounted on them during system-level blocks.

Why Most Developers Get This Wrong

Trusting legacy APM agents: Relying on standard JVM TI (Tooling Interface) agents that introduce massive safepoint overhead and fail under the sheer volume of millions of virtual threads.
Ignoring the Carrier Thread abstraction: Assuming OS-level CPU usage maps 1:1 to your business logic, when in reality, the kernel only sees the carrier thread, hiding virtual thread pinning and starvation.
Failing to correlate thread IDs: Thinking Thread.currentThread().threadId() matches the kernel TID, which breaks down entirely when virtual threads are multiplexed.

The Right Way

To achieve zero-overhead continuous profiling, you must stitch kernel-space eBPF stack traces with user-space Loom state by tracking virtual thread mounting and unmounting events in the JVM.

Leverage JVM USDT (Userland Statically Defined Tracing) Probes: Tap into internal JVM transition events to capture when a virtual thread mounts or unmounts from a carrier thread.
Maintain a BPF Map for Context: Use a shared eBPF map keyed by the OS Thread ID (TID) to store the active java.lang.VirtualThread object address or correlation ID.
Stitch Stacks JIT-Side: Correlate the kernel stack (retrieved via bpf_get_stackid) with the JVM frame pointer stack at the exact moment of the OS-level block (e.g., sys_enter_epoll_wait).

Shameless plug: javalld.com has full LLD implementations with step-by-step execution traces — free to use while prepping.

Show Me The Code (or Example)

The following eBPF C snippet intercepts JVM virtual thread mount events to map the OS carrier thread to the active logical virtual thread ID:

// eBPF map tracking: Carrier TID -> Virtual Thread ID
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __type(key, u32); // Carrier Thread TID
    __type(value, u64); // Virtual Thread ID Address
    __uint(max_entries, 32768);
} vthread_map SEC(".maps");

SEC("uprobe/libjvm/virtual_thread_mount")
int handle_vthread_mount(struct pt_regs *ctx) {
    u32 carrier_tid = bpf_get_current_pid_tgid();
    u64 vthread_id = PT_REGS_PARM1(ctx); // Read vthread object reference
    bpf_map_update_elem(&vthread_map, &carrier_tid, &vthread_id, BPF_ANY);
    return 0;
}

Key Takeaways

Stop relying on old-school Thread Locals: Virtual threads hop across carrier threads; your profiling context must be dynamically mapped via eBPF.
USDT is your bridge: Use JVM's internal tracing points to update eBPF maps in real-time with zero JVM-side overhead.
Stitch, don't guess: True observability in 2026 requires merging physical kernel-level execution with logical virtual-thread lifecycles.

Java 26 Structured Concurrency: Stop Subclassing StructuredTaskScope and Use JEP 480 Joiners

Machine coding Master — Tue, 26 May 2026 06:32:05 +0000

Java 26 Structured Concurrency: Stop Subclassing StructuredTaskScope and Use JEP 480 Joiners

With Java 26 finalizing Structured Concurrency under JEP 480, it's time to delete your legacy preview code that subclasses StructuredTaskScope. The era of extending this class for custom gather-scatter policies is officially over, replaced by a much cleaner, composition-first Joiner API.

Why Most Developers Get This Wrong

Cargo-culting outdated tutorials: Many developers are still copying early preview examples that forced you to subclass StructuredTaskScope (like creating custom variants of ShutdownOnFailure) just to implement custom result aggregation.
Brittle inheritance: Writing stateful subclasses of StructuredTaskScope violates basic OOP composition principles and introduces unnecessary thread-safety risks when coordinating virtual threads.
Ignoring the deprecation path: Failing to realize that subclassing is now an anti-pattern; the engine class is designed to be configured via composition, not extended.

The Right Way

Shift from inheritance to composition by leveraging the new StructuredTaskScope.Joiner interface to inject custom aggregation and short-circuiting logic directly into the scope.

Instantiate scopes exclusively using the new static factory StructuredTaskScope.open(Joiner) instead of extending the class.
Implement custom policies by writing a lightweight Joiner that handles task results via onFork and determines when to wake the owner thread via onComplete.
Keep your concurrency coordination completely stateless, reusable, and decoupled from the lifecycle of the virtual threads themselves.
Leverage the built-in factory methods like Joiner.allSuccessful() or Joiner.anySuccessful() for standard patterns before writing custom implementations.

Show Me The Code

// Java 26 composition: Pass a Joiner directly to the scope
var joiner = StructuredTaskScope.Joiner.<String>allSuccessful(); 
try (var scope = StructuredTaskScope.open(joiner)) {
    var task1 = scope.fork(() -> fetchFromServiceA());
    var task2 = scope.fork(() -> fetchFromServiceB());

    scope.join(); // Blocks until joiner condition is met
    List<String> results = scope.joiner().results(); // Clean, type-safe composition
}

Key Takeaways

Composition over Inheritance: JEP 480 deprecates subclassing StructuredTaskScope; always use StructuredTaskScope.open(joiner) for modern virtual thread coordination.
Decoupled Policies: Custom gather-scatter logic belongs in a Joiner implementation, keeping your task coordination logic clean and unit-testable.
Future-Proof Concurrency: Refactor your virtual thread code immediately to align with the finalized Java 26 standard before preview flags are dropped.

If you're prepping for interviews, I've been building javalld.com — real machine coding problems with full execution traces.

Stop Polling Your Outbox: Lightweight Event Streaming with Postgres LISTEN/NOTIFY and Java Virtual Threads

Machine coding Master — Mon, 25 May 2026 06:53:44 +0000

Stop Polling Your Outbox: Lightweight Event Streaming with Postgres LISTEN/NOTIFY and Java Virtual Threads

For years, we’ve tolerated the operational headache of spinning up heavy Kafka Connect or Debezium clusters just to sync our transactional outbox tables. But in 2026, with Java's virtual threads fully mature and mainstream, blocking a database connection to wait on events is no longer an architectural sin—it's a massive simplification.

Why Most Developers Get This Wrong

The Polling Tax: Constantly querying SELECT * FROM outbox WHERE status = 'PENDING' LIMIT 100 shreds your database indexes, bloats transaction logs, and spikes CPU for no reason.
Over-Engineering with CDC: Bootstrapping a complete Change Data Capture pipeline for a simple microservice boundary is operational overkill that introduces unnecessary network hops.
Thread Starvation Fears: Developers still avoid blocking JDBC drivers like PostgreSQL's notification listener because they mistakenly think it will choke their thread pools.

The Right Way

Leverage PostgreSQL's native LISTEN/NOTIFY system bound directly to a dedicated Java virtual thread that blocks cheaply and reacts instantly.

Virtual Thread Per Listener: Spawn an unpinned virtual thread using Thread.ofVirtual().start() to run a blocking getNotifications() loop.
Database Triggers: Use a lightweight Postgres trigger on your outbox table to automatically execute NOTIFY outbox_channel, payload on insert.
Zero-Overhead Parsing: Read the notification payload directly in Java, deserialize it, and dispatch it to your event broker instantly.

Show Me The Code

// Executed inside Thread.ofVirtual().start(...)
try (var conn = dataSource.getConnection()) {
    var pgConn = conn.unwrap(PGConnection.class);
    conn.createStatement().execute("LISTEN outbox_channel");
    while (!Thread.currentThread().isInterrupted()) {
        // Blocks cheaply on a virtual thread, yielding the carrier thread
        var notifications = pgConn.getNotifications(10000);
        if (notifications != null) {
            for (var notification : notifications) {
                eventPublisher.publish(notification.getParameter());
            }
        }
    }
} catch (SQLException e) { log.error("Listener failed", e); }

Key Takeaways

Drop CDC Overhead: You don't need Debezium or Kafka Connect for simple transactional outbox patterns anymore.
Zero Polling Latency: Events are pushed immediately from Postgres to your Java application via TCP, cutting latency to sub-millisecond.
Infinite Scale on JVM: Because Virtual Threads are virtually free, you can run hundreds of dedicated listeners without exhausting the OS thread pool.

Want to go deeper? javalld.com — machine coding interview problems with working Java code and full execution traces.