Performance & Production Engineering — Java

// BAD: allocates a new byte array per request
public byte[] serialize(Order order) {
    byte[] buffer = new byte[4096];
    // ... serialize into buffer
    return buffer;
}

// GOOD: reuse buffers via ThreadLocal pool
private static final ThreadLocal<byte[]> BUFFER_POOL =
    ThreadLocal.withInitial(() -> new byte[4096]);

public byte[] serialize(Order order) {
    byte[] buffer = BUFFER_POOL.get();
    // ... serialize into buffer, return copy of used portion
    return Arrays.copyOf(buffer, actualLength);
}

// Direct ByteBuffer — allocated outside JVM heap, no GC pressure
ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024);
buffer.putLong(timestamp);
buffer.putDouble(price);
buffer.flip();

// Read back
long ts = buffer.getLong();
double px = buffer.getDouble();

// CAS-based counter — no locks, no blocking
private final AtomicLong counter = new AtomicLong(0);

public long increment() {
    return counter.incrementAndGet();
}

// CAS loop for complex operations
public boolean compareAndSwap(AtomicReference<Node> head, Node expected, Node newNode) {
    return head.compareAndSet(expected, newNode);
}

// False sharing example — two threads updating adjacent fields
// BAD: fields share a cache line
class SharedState {
    volatile long counter1; // Thread 1 writes
    volatile long counter2; // Thread 2 writes — same cache line!
}

// GOOD: pad to separate cache lines
class SharedState {
    volatile long counter1;
    long p1, p2, p3, p4, p5, p6, p7; // padding (7 * 8 = 56 bytes)
    volatile long counter2;
}

// Standard — 50M entries = ~800MB with Integer boxing
Map<Integer, Integer> map = new HashMap<>();

// Eclipse Collections — 50M entries = ~200MB, no boxing
IntIntHashMap map = new IntIntHashMap();
map.put(42, 100);
int value = map.get(42); // no unboxing

// LEAK 1: Static collection growing forever
public class MetricsCollector {
    private static final List<Metric> allMetrics = new ArrayList<>();

    public void record(Metric m) {
        allMetrics.add(m); // never removed!
    }
}

// LEAK 2: Listeners never unregistered
public class OrderService {
    public void processOrder(Order order) {
        eventBus.register(new OrderListener(order)); // never unregistered
    }
}

// LEAK 3: ThreadLocal not cleaned in thread pools
public class RequestContext {
    private static final ThreadLocal<UserSession> session = new ThreadLocal<>();

    public void handle(Request req) {
        session.set(new UserSession(req));
        process(req);
        // Missing: session.remove() — thread returns to pool with session attached
    }
}

// LEAK 4: Unbounded cache
private final Map<String, byte[]> cache = new ConcurrentHashMap<>();
// Fix: Use Caffeine with maxSize or expireAfterWrite

// TERRIBLE: all threads block on the same interned String object
public void process(String key) {
    synchronized (key.intern()) { // ALL "order" strings are the same object!
        // ...
    }
}

// Fix: Use ConcurrentHashMap.computeIfAbsent or Striped locks

// BAD: creates millions of Integer objects
long sum = 0L;
for (Integer value : map.values()) { // unboxing
    sum += value; // more unboxing
}

// GOOD: use primitive streams
long sum = map.values().stream().mapToLong(Integer::intValue).sum();

// BAD: compiles regex 1M times
for (String line : lines) {
    if (line.matches("\\d{4}-\\d{2}-\\d{2}")) { // compiles Pattern each call!
        process(line);
    }
}

// GOOD: compile once
private static final Pattern DATE_PATTERN = Pattern.compile("\\d{4}-\\d{2}-\\d{2}");

for (String line : lines) {
    if (DATE_PATTERN.matcher(line).matches()) {
        process(line);
    }
}

// BAD: 1 query for orders + N queries for items
List<Order> orders = orderRepository.findAll();
for (Order order : orders) {
    order.getItems().size(); // triggers lazy load per order!
}

// GOOD: fetch join
@Query("SELECT o FROM Order o JOIN FETCH o.items")
List<Order> findAllWithItems();

// BAD: exceptions are 100-1000x slower than conditionals
public int parseOrDefault(String s, int defaultValue) {
    try {
        return Integer.parseInt(s);
    } catch (NumberFormatException e) {
        return defaultValue; // using exception for normal flow!
    }
}

// GOOD: check first
public int parseOrDefault(String s, int defaultValue) {
    if (s == null || !s.matches("-?\\d+")) return defaultValue;
    return Integer.parseInt(s);
}

// BAD: if consumer is slower than producer, memory grows forever
BlockingQueue<Event> queue = new LinkedBlockingQueue<>(); // unbounded!

// GOOD: bounded with backpressure
BlockingQueue<Event> queue = new ArrayBlockingQueue<>(10_000);
// producer blocks when full, creating natural backpressure

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 10, time = 1)
@Fork(2)
@State(Scope.Benchmark)
public class MapBenchmark {

    private Map<String, Integer> hashMap;
    private Map<String, Integer> concurrentMap;
    private String[] keys;

    @Setup
    public void setup() {
        hashMap = new HashMap<>();
        concurrentMap = new ConcurrentHashMap<>();
        keys = new String[1000];
        for (int i = 0; i < 1000; i++) {
            keys[i] = "key-" + i;
            hashMap.put(keys[i], i);
            concurrentMap.put(keys[i], i);
        }
    }

    @Benchmark
    public Integer hashMapGet() {
        return hashMap.get(keys[ThreadLocalRandom.current().nextInt(1000)]);
    }

    @Benchmark
    public Integer concurrentMapGet() {
        return concurrentMap.get(keys[ThreadLocalRandom.current().nextInt(1000)]);
    }
}