high-performance java techniques

// ❌ Tạo StringBuilder mới mỗi request (GC pressure)
public String buildResponse(List<Item> items) {
   StringBuilder sb = new StringBuilder();  // Allocated on heap, GC later
   for (Item item : items) {
       sb.append(item.getName()).append(",");
   }
   return sb.toString();
}
 
// ✅ ThreadLocal StringBuilder pool — reuse per thread
private static final ThreadLocal<StringBuilder> SB_POOL =
   ThreadLocal.withInitial(() -> new StringBuilder(1024));
 
public String buildResponse(List<Item> items) {
   StringBuilder sb = SB_POOL.get();
   sb.setLength(0);  // Reset, không allocate mới
   for (Item item : items) {
       sb.append(item.getName()).append(",");
   }
   return sb.toString();
}

# HikariCP = object pool cho database connections
spring:
  datasource:
    hikari:
      maximum-pool-size: 20 # Pre-create 20 connections
      minimum-idle: 5 # Keep 5 idle, ready to use
      # getConnection() → borrow từ pool (< 1ms)
      # thay vì tạo mới (TCP + TLS + auth, thường từ vài ms tới vài chục ms trở lên)

// Netty's PooledByteBufAllocator concept — simplified
public class ByteArrayPool {
   private final Queue<byte[]> pool = new ConcurrentLinkedQueue<>();
   private final int bufferSize;
 
   public ByteArrayPool(int bufferSize, int initialSize) {
       this.bufferSize = bufferSize;
       for (int i = 0; i < initialSize; i++) {
           pool.offer(new byte[bufferSize]);
       }
   }
 
   public byte[] borrow() {
       byte[] buf = pool.poll();
       return buf != null ? buf : new byte[bufferSize];
   }
 
   public void returnBuffer(byte[] buf) {
       if (buf.length == bufferSize) {
           pool.offer(buf);  // Return to pool for reuse
       }
   }
}

// ❌ Boxed (heap allocation mỗi element, GC phải track)
List<Integer> scores = new ArrayList<>();  // ~20 bytes/element (object overhead)
int sum = scores.stream().mapToInt(Integer::intValue).sum();  // Unboxing cost
 
// ✅ Primitive array (contiguous memory, cache-friendly)
int[] scores = new int[1000];  // 4 bytes/element, contiguous
int sum = 0;
for (int score : scores) sum += score;  // No boxing/unboxing
 
// Khi CẦN collection behavior + primitives → Eclipse Collections / HPPC
IntArrayList scores = new IntArrayList(1000);  // Primitive int list, no boxing
long sum = scores.sum();  // Eclipse Collections: sum() trả về long, no auto-boxing

// ❌ Process 1M records with boxed IDs
List<Long> ids = repository.findAllIds();  // 1M Long objects ≈ 28MB heap (24 bytes/Long + 4 bytes ref)
ids.forEach(id -> process(id));
 
// ⚠️ Unbox sau khi đã load cả List: không tiết kiệm được gì,
// 1M Long vẫn nằm trong heap như trên
repository.findAllIds().stream()
   .mapToLong(Long::longValue)
   .forEach(this::processById);
 
// ✅ Stream từ DB: đọc tới đâu xử lý tới đó, không giữ cả list trong memory
// (vẫn là Long boxed, nhưng object chết ngay sau khi xử lý)
@Query(value = "SELECT id FROM products WHERE status = 'ACTIVE'", nativeQuery = true)
Stream<Long> streamAllActiveIds();

// ❌ Hàng ngàn duplicate strings từ DB queries
List<Order> orders = orderRepository.findAll();  // 100K orders
// Mỗi order.getCurrency() = new String("VND") → 100K identical String objects
 
// ✅ String.intern() → share reference từ String Pool
public class Order {
   private String currency;
 
   public void setCurrency(String currency) {
       this.currency = currency.intern();  // Reuse existing String from pool
       // 100K orders nhưng chỉ 3-5 unique currency Strings in memory
   }
}
 
// ✅✅ Enum thay vì String (best approach cho fixed set of values)
public enum Currency { VND, USD, EUR, JPY }
// Zero allocation, zero GC, type-safe, comparable, serializable

# G1GC tự detect duplicate strings và deduplicate
java -XX:+UseG1GC -XX:+UseStringDeduplication -jar app.jar
# Không cần code change — JVM handles automatically
# Effective khi app có nhiều duplicate strings (parsed from DB/files)

// ❌ Eager — always compute, even if never used
@Service
public class ReportService {
   private final Map<String, ReportTemplate> templates;
 
   public ReportService() {
       this.templates = loadAllTemplates();  // 500ms startup, may never use all
   }
}
 
// ✅ Lazy with double-checked locking (thread-safe)
@Service
public class ReportService {
   private volatile Map<String, ReportTemplate> templates;
 
   public Map<String, ReportTemplate> getTemplates() {
       Map<String, ReportTemplate> result = templates;
       if (result == null) {
           synchronized (this) {
               result = templates;
               if (result == null) {
                   templates = result = loadAllTemplates();
               }
           }
       }
       return result;
   }
}
 
// ✅✅ Java's built-in lazy holders (cleanest pattern)
public class ExpensiveComputation {
   // Inner class NOT loaded until first access → thread-safe lazy init
   private static class Holder {
       static final ExpensiveComputation INSTANCE = new ExpensiveComputation();
   }
 
   public static ExpensiveComputation getInstance() {
       return Holder.INSTANCE;  // Class loaded lazily by JVM
   }
}
 
// ✅✅✅ computeIfAbsent — cache computed results
private final Map<UUID, ProductDTO> cache = new ConcurrentHashMap<>();
 
public ProductDTO getProduct(UUID id) {
   return cache.computeIfAbsent(id, this::loadFromDatabase);
   // First call: compute + cache. Subsequent calls: return cached. Thread-safe.
}

// ❌ Pattern compilation mỗi lần gọi (regex compile = expensive)
public boolean isValidEmail(String email) {
   return email.matches("^[A-Za-z0-9+_.-]+@(.+)$");  // Compiles Pattern EVERY CALL
}
 
// ✅ Pre-compile once, reuse forever
private static final Pattern EMAIL_PATTERN =
   Pattern.compile("^[A-Za-z0-9+_.-]+@(.+)$");
 
public boolean isValidEmail(String email) {
   return EMAIL_PATTERN.matcher(email).matches();  // Reuse compiled pattern
}
 
// ❌ DateTimeFormatter mới mỗi lần
public String format(LocalDateTime dt) {
   return dt.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));  // Parse pattern each time
}
 
// ✅ Static formatter (thread-safe since Java 8)
private static final DateTimeFormatter FORMATTER =
   DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
 
public String format(LocalDateTime dt) {
   return dt.format(FORMATTER);
}
 
// ❌ Autoboxing in loop
Long sum = 0L;  // Boxed Long!
for (long val : values) {
   sum += val;  // Unbox, add, RE-BOX → millions of Long objects created!
}
 
// ✅ Primitive in loop
long sum = 0L;
for (long val : values) {
   sum += val;  // Pure arithmetic, zero allocation
}

// ❌ Array of objects (pointer chasing → cache misses)
class Point { double x, y; }
Point[] points = new Point[1_000_000];
// Memory: [ptr1, ptr2, ptr3, ...] → [Point@heap1] → [Point@heap2] → scattered!
 
double sumX = 0;
for (Point p : points) sumX += p.x;  // Each p.x = random memory access
 
// ✅ Struct of Arrays (SoA) — contiguous per field
double[] xs = new double[1_000_000];  // All X values contiguous
double[] ys = new double[1_000_000];  // All Y values contiguous
 
double sumX = 0;
for (int i = 0; i < xs.length; i++) sumX += xs[i];
// Sequential memory access → CPU prefetcher happy → thường nhanh hơn rõ rệt, mức chênh tuỳ data
 
// ✅ Spring Boot application: Batch processing with arrays
@Service
public class BulkPriceCalculator {
 
   // Instead of List<Product> → process price arrays
   public double[] calculateDiscounts(double[] prices, double discountRate) {
       double[] results = new double[prices.length];
       for (int i = 0; i < prices.length; i++) {
           results[i] = prices[i] * (1 - discountRate);
       }
       return results;  // Vectorizable by JIT compiler (SIMD instructions)
   }
}

// ❌ Synchronized counter (threads block each other)
public class SyncCounter {
   private int count = 0;
   public synchronized void increment() { count++; }  // Lock acquire + release
   public synchronized int get() { return count; }
}
 
// ✅ AtomicInteger (lock-free)
public class AtomicCounter {
   private final AtomicInteger count = new AtomicInteger(0);
   public void increment() { count.incrementAndGet(); }  // No lock (x86: 1 lệnh LOCK XADD)
   public int get() { return count.get(); }
}
 
// ✅ LongAdder — even faster under HIGH contention
// Internally: multiple cells, each thread updates its own cell, sum on read
public class HighThroughputCounter {
   private final LongAdder counter = new LongAdder();
   public void increment() { counter.increment(); }  // Striped, minimal contention
   public long get() { return counter.sum(); }        // Sum all cells
}
 
// Thứ tự thường thấy khi nhiều thread cùng tăng 1 counter:
// synchronized ≈ AtomicLong (cùng tranh nhau 1 cache line) chậm hơn LongAdder nhiều lần.
// Con số tuyệt đối tuỳ CPU, số core, JVM: tự đo bằng JMH trên máy của bạn.

// Fixed-window rate limiter lock-free: mỗi giây một cửa sổ,
// sang giây mới thì bộ đếm tự reset
public class FixedWindowRateLimiter {
 
   private final int maxRequestsPerSecond;
   // Gói (giây hiện tại, số request) vào 1 long để cập nhật bằng 1 lần CAS:
   // 32 bit cao = epoch second, 32 bit thấp = count
   private final AtomicLong state = new AtomicLong();
 
   public FixedWindowRateLimiter(int maxRequestsPerSecond) {
       this.maxRequestsPerSecond = maxRequestsPerSecond;
   }
 
   public boolean tryAcquire() {
       long nowSec = System.currentTimeMillis() / 1000;
       while (true) {
           long current = state.get();
           long windowSec = current >>> 32;
           int count = (int) current;
           long next;
           if (windowSec != nowSec) {
               next = (nowSec << 32) | 1;          // Sang giây mới: reset về 1
           } else if (count < maxRequestsPerSecond) {
               next = current + 1;                 // Cùng giây: tăng count
           } else {
               return false;                       // Hết quota của giây này
           }
           if (state.compareAndSet(current, next)) {
               return true;
           }
           // CAS thất bại: thread khác vừa cập nhật, đọc lại rồi thử tiếp
       }
   }
}

// ❌ N+1 problem — 1000 individual saves
for (Product product : products) {
   productRepository.save(product);  // 1000 INSERT statements, 1000 round-trips
}
 
// ✅ Batch insert (gom statement theo lô)
@Transactional
public void batchInsert(List<Product> products) {
   // JPA batch: spring.jpa.properties.hibernate.jdbc.batch_size=50
   productRepository.saveAll(products);  // 50 INSERT mỗi lô → 1000 rows ≈ 20 round-trips
}
 
// ✅✅ Native batch (fastest — bypass Hibernate overhead)
@Transactional
public void nativeBatchInsert(List<Product> products) {
   String sql = "INSERT INTO products (id, name, price, status) VALUES (?, ?, ?, ?)";
   jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
       @Override
       public void setValues(PreparedStatement ps, int i) throws SQLException {
           Product p = products.get(i);
           ps.setObject(1, p.getId());
           ps.setString(2, p.getName());
           ps.setBigDecimal(3, p.getPrice());
           ps.setString(4, p.getStatus().name());
       }
       @Override
       public int getBatchSize() { return products.size(); }
   });
   // 1 JDBC batch cho tất cả rows (gửi đi mấy round-trip là tuỳ driver)
}
 
// ✅ MongoDB bulk operations
public void bulkUpdate(List<ProductUpdate> updates) {
   BulkOperations bulkOps = mongoTemplate.bulkOps(BulkOperations.BulkMode.UNORDERED, "products");
   for (ProductUpdate update : updates) {
       Query query = Query.query(Criteria.where("_id").is(update.getId()));
       Update mongoUpdate = new Update().set("price", update.getNewPrice());
       bulkOps.updateOne(query, mongoUpdate);
   }
   BulkWriteResult result = bulkOps.execute();  // 1 round-trip for all updates
}

// ❌ Traditional I/O (multiple copies)
byte[] data = Files.readAllBytes(path);  // Copy 1: disk → kernel buffer → user buffer
response.getOutputStream().write(data);   // Copy 2: user buffer → kernel socket buffer
 
// ✅ Không load cả file vào heap: Spring stream file ra response
@GetMapping("/files/{id}")
public ResponseEntity<Resource> downloadFile(@PathVariable UUID id) {
   Path filePath = storageService.getPath(id);
   Resource resource = new FileSystemResource(filePath);
 
   return ResponseEntity.ok()
       .contentType(MediaType.APPLICATION_OCTET_STREAM)
       .body(resource);
   // Spring MVC copy file qua buffer nhỏ (InputStream.transferTo) → không tốn heap theo kích thước file,
   // nhưng dữ liệu vẫn đi qua user space. Zero-copy thật (sendfile) có ở WebFlux + Reactor Netty
}
 
// ✅ StreamingResponseBody — no full file in memory
@GetMapping("/export")
public ResponseEntity<StreamingResponseBody> export() {
   StreamingResponseBody body = outputStream -> {
       // Spring Data MongoDB 3.x+: stream() trả về java.util.stream.Stream, phải đóng sau khi dùng
       try (Stream<Document> docs = mongoTemplate.stream(query, Document.class)) {
           Iterator<Document> it = docs.iterator();
           while (it.hasNext()) {
               Document doc = it.next();
               outputStream.write(toCsvLine(doc).getBytes(StandardCharsets.UTF_8));
               // Stream line by line — never hold full dataset in memory
           }
       }
   };
   return ResponseEntity.ok().body(body);
}

// HashMap vs EnumMap — when keys are enum
// ❌ HashMap with Enum keys (hash computation, node object mỗi entry)
Map<OrderStatus, List<Order>> grouped = new HashMap<>();
 
// ✅ EnumMap (array-based internally, O(1) access, no hashing)
Map<OrderStatus, List<Order>> grouped = new EnumMap<>(OrderStatus.class);
// Nhanh hơn và ít memory hơn HashMap cho enum keys
 
// ArrayList vs LinkedList (almost ALWAYS ArrayList wins)
// LinkedList only wins for: frequent add/remove at HEAD (use as Deque)
 
// HashSet.contains() vs sorted array + binary search
// Small set (<20 elements): array scan can be faster (no hashing overhead)
// Large set: HashSet O(1) amortized
 
// ✅ Specialized collections for high-performance
// Agrona (used by Aeron messaging): Int2ObjectHashMap, MutableLong
// Eclipse Collections: IntArrayList, LongHashSet, UnifiedMap
// HPPC: IntIntHashMap (primitive-to-primitive, zero boxing)
 
// ✅ Pre-size collections
// ❌
List<ProductDTO> results = new ArrayList<>();  // Default capacity 10, grows via arraycopy
// ✅
List<ProductDTO> results = new ArrayList<>(expectedSize);  // No resize needed
Map<String, Object> map = HashMap.newHashMap(expectedSize);  // Java 19+, or capacity = size/0.75+1

// ✅ Small methods → JIT can INLINE (eliminate method call overhead)
// Method < 35 bytes bytecode (MaxInlineSize) được inline cả khi chưa nóng;
// method nóng được inline tới 325 bytes (FreqInlineSize)
public boolean isActive(Product p) { return p.getStatus() == ProductStatus.ACTIVE; }
// JIT inlines this → zero method call overhead at call sites
 
// ❌ Megamorphic dispatch blocks inlining
interface Processor { void process(Data d); }
// Nếu tại cùng 1 call site JIT thấy 3+ kiểu thực tế → không inline → virtual dispatch every call
// Fix: limit implementations, or restructure to avoid hot polymorphic calls
 
// ✅ Final classes/methods → devirtualization
public final class FastCalculator {  // JIT biết chắc không có subclass
   public final double compute(double x) { return x * x + 1; }
}
// (HotSpot vốn tự devirtualize qua class hierarchy analysis khi chưa load subclass nào,
// nên final thường không làm nhanh thêm bao nhiêu)
 
// Loop-invariant code motion — JIT thường tự làm việc này:
// ❌
for (int i = 0; i < list.size(); i++) { ... }  // list.size() called each iteration
// ✅
int size = list.size();
for (int i = 0; i < size; i++) { ... }  // Hoisted out of loop
// (size() ngắn nên được inline; hoist tay chủ yếu có ích khi lời gọi đắt thật)
 
// ✅ Avoid megamorphic calls in hot loops
// JIT optimizes monomorphic (1 type) and bimorphic (2 types) call sites
// 3+ types at same call site → megamorphic → slow virtual dispatch

// ConcurrentHashMap — Java 7: segment locking; Java 8+: CAS + synchronized trên từng bin
ConcurrentHashMap<UUID, ProductDTO> cache = new ConcurrentHashMap<>();
cache.computeIfAbsent(id, k -> loadProduct(k));  // Atomic compute, no external lock
 
// CopyOnWriteArrayList — reads never block (copy on write)
// Perfect for: rarely-modified, frequently-read lists (event listeners, config)
List<EventHandler> handlers = new CopyOnWriteArrayList<>();
// Reads: zero synchronization. Writes: copy entire array (expensive but rare)
 
// ConcurrentLinkedQueue — lock-free FIFO queue (Michael-Scott algorithm)
Queue<Task> taskQueue = new ConcurrentLinkedQueue<>();
// Non-blocking add/poll — ideal for producer-consumer without locks
 
// Disruptor pattern (LMAX) — mechanical sympathy, ring buffer
// Theo benchmark của LMAX: hơn 25M messages/second (1 producer, 1 consumer), latency ổn định
// Used in: trading systems, high-throughput event processing

// Cho large files (GB+): mmap = OS manages caching, zero explicit I/O
// File acts like byte array in memory — OS pages in/out automatically
// Lưu ý: 1 MappedByteBuffer tối đa Integer.MAX_VALUE bytes (~2GB).
// File lớn hơn phải map từng đoạn, hoặc dùng channel.map(mode, 0, size, arena)
// trả về MemorySegment (FFM API, Java 22+) không bị giới hạn này
 
try (FileChannel channel = FileChannel.open(path, StandardOpenOption.READ)) {
   MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_ONLY, 0, channel.size());
   // 'buffer' is now backed by OS page cache
   // Random access = O(1), OS handles prefetching
   // No explicit read() calls needed — access like array
 
   while (buffer.hasRemaining()) {
       byte b = buffer.get();  // Không gọi read(); trang chưa có trong RAM thì page fault → OS đọc đĩa
   }
}
 
// Use case: Log file processing, large CSV parsing, database file access
// SharedMemory between processes (IPC)

// ✅ Object that DOESN'T escape method → JIT có thể bỏ hẳn allocation (scalar replacement, no GC!)
public double calculateDistance(double x1, double y1, double x2, double y2) {
   Point p1 = new Point(x1, y1);  // JIT: p1 doesn't escape → không cần cấp phát trên heap
   Point p2 = new Point(x2, y2);  // JIT: p2 doesn't escape → không cần cấp phát trên heap
   return p1.distanceTo(p2);
   // Fields thành biến cục bộ/thanh ghi. Zero GC work.
}
 
// ❌ Object ESCAPES method → must heap allocate
public Point createPoint(double x, double y) {
   return new Point(x, y);  // Returned to caller → escapes → heap allocated → GC tracks
}
 
// Help escape analysis:
// - Keep methods small (easier for JIT to analyze)
// - Avoid storing local objects into fields/collections
// - Avoid passing local objects to methods that might store them
// - Use records/value types for small temporary data