Mini-challenge: Debug memory leak với heap dump và JFR

import java.time.Instant;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicLong;

public class EventTrackerApp {

    public record Event(String id, String userId, String button, Instant timestamp) { }

    public static class EventCache implements AutoCloseable {
        private final Map<String, List<Event>> cache = new ConcurrentHashMap<>();
        private final ScheduledExecutorService cleaner;
        private final long ttlSeconds;

        public EventCache(long ttlSeconds) {
            this.ttlSeconds = ttlSeconds;
            this.cleaner = Executors.newSingleThreadScheduledExecutor(r -> {
                Thread t = new Thread(r, "EventCache-Cleaner");
                t.setDaemon(true);
                return t;
            });
            cleaner.scheduleAtFixedRate(this::cleanup, 1, 1, TimeUnit.MINUTES);
        }

        public void add(Event e) {
            cache.compute(e.userId(), (k, existing) -> {
                List<Event> list = existing != null ? existing : new ArrayList<>();
                synchronized (list) {
                    list.add(e);
                }
                return list;
            });
        }

        public List<Event> getEventsLast24h(String userId) {
            List<Event> userEvents = cache.get(userId);
            if (userEvents == null) return List.of();
            Instant cutoff = Instant.now().minusSeconds(ttlSeconds);
            synchronized (userEvents) {
                return userEvents.stream()
                    .filter(e -> e.timestamp().isAfter(cutoff))
                    .toList();
            }
        }

        private void cleanup() {
            Instant cutoff = Instant.now().minusSeconds(ttlSeconds);
            int removed = 0;
            for (Iterator<Map.Entry<String, List<Event>>> it = cache.entrySet().iterator(); it.hasNext(); ) {
                Map.Entry<String, List<Event>> entry = it.next();
                List<Event> list = entry.getValue();
                synchronized (list) {
                    int before = list.size();
                    list.removeIf(e -> e.timestamp().isBefore(cutoff));
                    removed += before - list.size();
                    if (list.isEmpty()) {
                        it.remove();
                    }
                }
            }
            System.err.println("[Cleanup] Removed " + removed + " stale events. Cache size: " + size());
        }

        public int size() {
            int total = 0;
            for (List<Event> list : cache.values()) {
                synchronized (list) {
                    total += list.size();
                }
            }
            return total;
        }

        public int userCount() {
            return cache.size();
        }

        @Override
        public void close() {
            cleaner.shutdown();
        }
    }

    public static class EventTracker {
        private final EventCache cache = new EventCache(86400);
        private final AtomicLong idGen = new AtomicLong();

        public void track(String userId, String button) {
            Event e = new Event(
                String.valueOf(idGen.incrementAndGet()),
                userId, button, Instant.now());
            cache.add(e);
        }

        public int statsLast24h(String userId) {
            return cache.getEventsLast24h(userId).size();
        }

        public int totalEvents() { return cache.size(); }
        public int activeUsers() { return cache.userCount(); }
    }

    public static void main(String[] args) throws InterruptedException {
        EventTracker tracker = new EventTracker();

        Thread monitor = new Thread(() -> {
            while (true) {
                try { Thread.sleep(5000); } catch (InterruptedException e) { return; }
                Runtime r = Runtime.getRuntime();
                long used = (r.totalMemory() - r.freeMemory()) / 1024 / 1024;
                long max = r.maxMemory() / 1024 / 1024;
                System.out.printf("Heap %d/%d MB | events: %d | users: %d%n",
                    used, max, tracker.totalEvents(), tracker.activeUsers());
            }
        });
        monitor.setDaemon(true);
        monitor.start();

        System.out.println("EventTracker started. PID: " + ProcessHandle.current().pid());
        Thread.currentThread().join();
    }
}

Heap 234/512 MB | events: 50000 | users: 1000
Heap 256/512 MB | events: 100000 | users: 1000
Heap 278/512 MB | events: 150000 | users: 1000
[Cleanup] Removed 0 stale events. Cache size: 150000
Heap 280/512 MB | events: 200000 | users: 1000
[Cleanup] Removed 0 stale events. Cache size: 200000
...

private final EventCache cache = new EventCache(60);   // TTL 60s for test

Heap 200/512 MB | events: 60000 | users: 1000
[Cleanup] Removed 0 stale events. Cache size: 60000
Heap 220/512 MB | events: 120000 | users: 1000
[Cleanup] Removed 60000 stale events. Cache size: 60000
Heap 220/512 MB | events: 120000 | users: 1000
[Cleanup] Removed 60000 stale events. Cache size: 60000
...

# Truoc fix - 5 phut
jcmd <PID> GC.class_histogram | head -5
# 1: 300000 events EventTrackerApp$Event 24 MB
# 2: 300000 events String 19 MB

# Truoc fix - 30 phut (neu chua OOM)
jcmd <PID> GC.class_histogram | head -5
# 1: 1800000 events EventTrackerApp$Event 144 MB
# 2: 1800000 events String 115 MB
# Growing 6x tuyen tinh -> leak

# Sau fix - 5 phut
jcmd <PID> GC.class_histogram | head -5
# 1: 60000 events EventTrackerApp$Event 4.8 MB
# 2: 60000 events String 3.8 MB

# Sau fix - 30 phut
jcmd <PID> GC.class_histogram | head -5
# 1: 60000 events EventTrackerApp$Event 4.8 MB
# 2: 60000 events String 3.8 MB
# Stable -> no leak