#内存溢出排查

// 原因一：一次性加载过多数据到内存
List<Order> orders = queryAllOrders();  // 1000万条订单，一次性加载

// 原因二：内存泄漏
Map<String, User> cache = new HashMap<>();
// 缓存没有过期机制，持续增长

// 原因三：JVM 堆设置过小
java -Xmx256m MyApp  // 在数据量增长后不够用

// 原因四： Eden/Survivor/Old 比例不当
// 导致大量对象直接进入 Old 区，Old 区迅速填满

// 原因一：动态生成大量类
// 如 CGLIB 代理、字节码生成框架
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(MyClass.class);
enhancer.setCallback((MethodInterceptor) (o, method, args, methodProxy) -> {
    return methodProxy.invokeSuper(o, args);
});
// 每次增强都生成新的子类字节码
for (int i = 0; i < 100000; i++) {
    enhancer.create();  // 动态生成类 → 撑爆 Metaspace
}

// 原因二：类加载器泄漏（Tomcat 热部署场景）
// 每个新的 WebAppClassLoader 加载的类不会被卸载

// 原因三：Metaspace 设置过小
-XX:MaxMetaspaceSize=128m  // 默认无上限，但显式设置后容易触发

// 递归调用没有正确的退出条件
public int factorial(int n) {
    return n * factorial(n - 1);  // 如果 n < 0，StackOverflow!
}

// 大数组分配在栈上
public void largeStack() {
    int[] arr = new int[Integer.MAX_VALUE];  // 栈空间不足
}

// 线程过多
for (int i = 0; i < 10000; i++) {
    new Thread(() -> {
        // 每个线程都有独立的栈空间
        // 线程数过多 → 栈内存耗尽
    }).start();
}

// NIO 使用直接内存（堆外内存）
ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024 * 1024);  // 1GB 直接内存

// 如果 JVM 配置了 -XX:MaxDirectMemorySize=1g
// 再申请 1GB 就会 OOM

// 数组最大长度：Integer.MAX_VALUE
// 但实际限制取决于可用连续内存
int[] arr = new int[Integer.MAX_VALUE];  // 可能失败

// 另一个例子：超过 -XX:MaxArraySize
ArrayList.ensureCapacity(Integer.MAX_VALUE - 8);

// 问题代码
@Service
public class UserProfileService {
    // 本地缓存，无过期机制
    private Map<String, UserProfile> profileCache = new HashMap<>();

    public UserProfile getProfile(String userId) {
        if (!profileCache.containsKey(userId)) {
            UserProfile profile = loadFromDB(userId);
            profileCache.put(userId, profile);
        }
        return profileCache.get(userId);
    }
}

// 使用 Caffeine Cache（高性能缓存，支持过期和淘汰）
@Service
public class UserProfileService {
    private LoadingCache<String, UserProfile> profileCache = Caffeine.newBuilder()
        .maximumSize(10_000)            // 最多缓存 10000 个用户
        .expireAfterWrite(30, TimeUnit.MINUTES)  // 写后 30 分钟过期
        .recordStats()                  // 开启统计
        .build(this::loadFromDB);       // 缓存未命中时自动加载

    public UserProfile getProfile(String userId) {
        return profileCache.get(userId);
    }
}

// 使用 LRU 缓存限制大小
private Map<String, UserProfile> profileCache =
    Collections.synchronizedMap(
        new LinkedHashMap<>(10000, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(
                    Map.Entry<String, UserProfile> eldest) {
                return size() > 10000;  // 超过 10000 条时淘汰最老的
            }
        });

// 方案一：限制 CGLIB 生成的代理类数量
@Configuration
public class CglibConfig {
    @Bean
    public Advisor advisor() {
        AspectJExpressionPointcut pointcut =
            new AspectJExpressionPointcut();
        pointcut.setExpression("execution(* com.example..*.*(..))");

        DefaultBeanFactoryPointcutAdvisor advisor =
            new DefaultBeanFactoryPointcutAdvisor();
        advisor.setAdvice(new MyInterceptor());
        advisor.setPointcut(pointcut);
        return advisor;
    }
}

// 方案二：使用 JDK 动态代理替代 CGLIB
// JDK 动态代理不需要生成新类，减少 Metaspace 压力

// 方案三：设置 Metaspace 上限并监控
-XX:MaxMetaspaceSize=256m \
-XX:MetaspaceSize=128m \
-XX:+UseGCOverheadLimit   // 提前触发 GC Overhead 警告