import java.util.ArrayList;
import java.util.List;

public class HeapMemoryOverflow {
    public static void main(String[] args) {
        List<Object> list = new ArrayList<>();
        while (true) {
            list.add(new Object());
        }
    }
}

public class StackMemoryOverflow {
    public static void main(String[] args) {
        recursiveMethod();
    }

    public static void recursiveMethod() {
        // 沒有終止條件的遞歸調(diào)用
        recursiveMethod();
    }
}

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class MetaspaceOverflow {
    public static void main(String[] args) {
        while (true) {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(DummyClass.class);
            enhancer.setUseCache(false);
            enhancer.setCallback(new MethodInterceptor() {
                @Override
                public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
                    return proxy.invokeSuper(obj, args);
                }
            });
            enhancer.create();
        }
    }

    static class DummyClass {
    }
}

import java.util.ArrayList;
import java.util.List;

public class StaticCollectionLeak {
    // 靜態(tài)集合持有對象引用
    private static List<Object> objectList = new ArrayList<>();

    public static void main(String[] args) {
        for (int i = 0; i < 10000; i++) {
            // 每次創(chuàng)建一個新對象并添加到靜態(tài)集合中
            objectList.add(new Object());
        }
        // 即使在這里試圖清理掉一些其他的引用
        System.gc();  // 這些對象仍然無法被回收，因為它們被靜態(tài)集合引用
    }
}

import java.util.ArrayList;
import java.util.List;

public class ListenerLeak {
    private List<EventListener> listeners = new ArrayList<>();

    public void addListener(EventListener listener) {
        listeners.add(listener);
    }

    public void triggerEvent() {
        for (EventListener listener : listeners) {
            listener.onEvent();
        }
    }

    public static void main(String[] args) {
        ListenerLeak leakExample = new ListenerLeak();
        
        // 匿名類創(chuàng)建的監(jiān)聽器對象
        leakExample.addListener(new EventListener() {
            @Override
            public void onEvent() {
                System.out.println("Event triggered");
            }
        });

        // 假設(shè)在某個時候不再需要監(jiān)聽器，但未移除
        // listeners.remove(listener); // 應(yīng)該移除不需要的監(jiān)聽器
    }
}

interface EventListener {
    void onEvent();
}

import java.util.HashMap;
import java.util.Map;

public class LongLifeCycleLeak {
    private static Map<String, byte[]> cache = new HashMap<>();

    public static void main(String[] args) {
        while (true) {
            // 短生命周期對象
            byte[] data = new byte[1024 * 1024]; // 1MB

            // 長生命周期對象持有短生命周期對象的引用
            cache.put(String.valueOf(System.nanoTime()), data);

            // 需要定期移除不再需要的數(shù)據(jù)，否則會導(dǎo)致內(nèi)存泄漏
            // cache.clear(); // 應(yīng)該在適當(dāng)時機清理緩存
        }
    }
}

import java.util.HashMap;
import java.util.Map;

public class MemoryLeakExample {
    private static Map<Integer, String> map = new HashMap<>();

    public static void main(String[] args) {
        for (int i = 0; i < 100000; i++) {
            map.put(i, "value" + i);
        }
    }
}