Minimize garbage collection by using object pooling, stack allocation via escape analysis, primitive collections, and limiting object churn, while leveraging low-pause GCs like ZGC or Shenandoah. 2. Use ring buffers and lock-free data structures such as the Disruptor pattern for high-throughput, low-latency inter-thread communication with pre-allocated events. 3. Optimize JIT compilation by warming up the JVM, tuning compilation thresholds, pinning critical methods, avoiding reflection in hot paths, and using profiling tools to monitor inlining and deoptimization. 4. Reduce contention through thread-per-core design and prevent false sharing by padding variables or using @Contended to isolate frequently modified fields on separate cache lines. 5. Use efficient I/O with NIO, direct buffers, zero-copy techniques like transferTo() or memory-mapped files, and high-performance serialization formats such as Protobuf, FlatBuffers, or SBE. 6. Pin threads to CPU cores, use real-time scheduling, disable CPU frequency scaling, and apply latency-focused JVM flags including -XX: UseZGC, -XX: AlwaysPreTouch, and -XX:-UseBiasedLocking to minimize system-level variability. By combining these techniques, Java applications can achieve microsecond-scale response times with high predictability, making them suitable for real-time, low-latency domains such as financial trading and gaming.

When building high-performance, real-time systems in Java—such as financial trading platforms, online gaming backends, or real-time data processing pipelines—low latency is critical. While Java is often perceived as "slower" due to garbage collection and JIT compilation, with the right techniques, it can achieve sub-millisecond response times consistently. Here are key low-latency Java programming techniques that help minimize delays and improve predictability.

1. Minimize Garbage Collection (GC) Pressure

Garbage collection is the biggest source of unpredictable pauses in Java applications. To reduce GC impact:

• Object pooling: Reuse objects instead of creating new ones. For example, use object pools for messages, buffers, or DTOs.
• Stack allocation via escape analysis: Write code that allows the JIT to allocate short-lived objects on the stack (e.g., avoid storing references in fields or collections).
• Use primitive collections: Libraries like Eclipse Collections or Trove avoid boxing by using int[] instead of Integer[].
• Limit object churn: Avoid unnecessary object creation in hot paths (e.g., don’t use new String("hello"), String.format(), or autoboxing in tight loops).

Example:

// Bad: creates temporary objects
String log = String.format("Error at %d", System.nanoTime());

// Better: use a reusable buffer or pre-allocated strings
StringBuilder sb = new StringBuilder();
sb.append("Error at ").append(System.nanoTime());

Also consider using ZGC or Shenandoah—low-pause GCs introduced in recent JDK versions—that can keep pauses under 10ms even with large heaps.

2. Use Ring Buffers and Lock-Free Data Structures

For inter-thread communication, traditional queues (like LinkedBlockingQueue) involve locks and memory allocation, which add latency.

• Disruptor pattern: Developed by LMAX, the Disruptor uses a ring buffer with memory barriers instead of locks, enabling million-messages-per-second throughput with microsecond latency.
• Wait-free or bounded queues: Use Phaser, AtomicReference, or VarHandle-based structures to avoid blocking.

Example (simplified Disruptor usage):

EventFactory<Event> factory = Event::new;
RingBuffer<Event> ringBuffer = RingBuffer.createSingleProducer(factory, 1024);
SequenceBarrier barrier = ringBuffer.newBarrier();

This design ensures predictable latency by pre-allocating all events and eliminating GC and lock contention.

3. Optimize JIT Compilation Behavior

The HotSpot JVM uses Just-In-Time (JIT) compilation to optimize hot methods. But this can cause "warm-up" delays.

• Warm up the JVM: Run representative workloads before measuring performance.
• Use -XX:CompileThreshold or tiered compilation tuning: Adjust when methods get compiled.
• Pin critical methods: Use -XX:CompileCommand=compileonly to force early compilation.
• Avoid reflection in hot paths: It inhibits inlining. Use method handles or code generation (e.g., via ASM or ByteBuddy) if needed.

Tip: Use JITWatch or Async-Profiler to identify methods that are not being inlined or are deoptimized.

4. Reduce Contention with Thread Confinement and False Sharing Avoidance

Thread contention adds latency unpredictably.

• Thread-per-core design: Assign dedicated threads to specific tasks to avoid synchronization.
• False sharing prevention: Pad variables to avoid adjacent data on the same cache line.

Example:

public class PaddedCounter {
    public volatile long value;
    private long p1, p2, p3, p4, p5, p6, p7; // Cache line padding
}

Or use @Contended (with -XX:-RestrictContended):

@jdk.internal.vm.annotation.Contended
public class IsolatedCounter {
    public volatile long value;
}

This ensures each counter lives in its own CPU cache line, preventing performance-killing false sharing.

5. Use Efficient I/O and Serialization

High-latency I/O can dominate end-to-end response time.

• NIO and direct buffers: Use ByteBuffer.allocateDirect() for off-heap I/O buffers to avoid copying.
• Zero-copy techniques: Leverage FileChannel.transferTo() or Memory-mapped files (MappedByteBuffer).
• Efficient serialization: Use Protobuf, FlatBuffers, or SBE (Simple Binary Encoding) instead of JSON or Java serialization.

SBE is especially popular in low-latency finance due to its schema-driven, zero-allocation decoding.

6. Pin Threads and Tune the OS/JVM

Even the best code can be derailed by OS scheduling.

• CPU affinity: Bind critical threads to specific CPU cores using taskset or APIs like JNA with sched_setaffinity.
• Real-time scheduling: On Linux, use SCHED_FIFO with chrt (requires root).
• Disable CPU frequency scaling: Use "performance" governor:

  echo performance | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor

• JVM flags for latency:

  -XX: UseZGC
  -XX: UnlockExperimentalVMOptions
  -XX: PerfDisableSharedMem
  -XX:-UseBiasedLocking
  -XX: AlwaysPreTouch
  -Xms4g -Xmx4g

  These reduce variability from memory allocation, locking, and background JVM processes.

  ---

  Low-latency Java isn’t about raw speed—it’s about predictability. The goal is to minimize jitter (variation in response time), not just average latency. By combining GC control, lock-free designs, JIT tuning, and system-level optimizations, Java can reliably achieve microsecond-scale responses.

  Basically, it’s not whether Java can be fast—it’s how carefully you manage resources and avoid hidden delays.

  The above is the detailed content of Low-Latency Java Programming Techniques. For more information, please follow other related articles on the PHP Chinese website!