线上Java OOM问题定位与解决方案超详细解析

jps -l

jstat -gc 12345 2000 10

jmap -dump:format=b,file=/Users/xxx/heapdump.hprof 12345

jhat /Users/xxx/heapdump.hprof

public class UserCache {
    // 静态HashMap，持有用户对象引用，不会被GC回收
    private static final Map<Long, User> USER_CACHE = new HashMap<>();

    // 添加用户到缓存，无清理逻辑
    public static void addUser(User user) {
        USER_CACHE.put(user.getId(), user);
    }

    // 获取缓存用户
    public static User getUser(Long userId) {
        return USER_CACHE.get(userId);
    }
}

// 服务层调用，持续添加用户到缓存
@Service
public class UserService {
    public void processUser(User user) {
        // 业务处理逻辑
        UserCache.addUser(user);
    }
}

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import java.util.concurrent.TimeUnit;

public class UserCache {
    // 配置缓存：最大容量10000，过期时间30分钟
    private static final Cache<Long, User> USER_CACHE = CacheBuilder.newBuilder()
            .maximumSize(10000) // 最大缓存对象数
            .expireAfterWrite(30, TimeUnit.MINUTES) // 写入后30分钟过期
            .build();

    public static void addUser(User user) {
        USER_CACHE.put(user.getId(), user);
    }

    public static User getUser(Long userId) {
        try {
            return USER_CACHE.getIfPresent(userId);
        } catch (Exception e) {
            return null;
        }
    }
}

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class OrderController {
    // 每个请求都创建新的Enhancer实例，动态生成代理类
    @GetMapping("/order/{id}")
    public String getOrder(@PathVariable Long id) {
        // 问题点：每次请求都动态生成OrderService的代理类，类信息堆积在元空间
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(OrderService.class);
        enhancer.setCallback((MethodInterceptor) (obj, method, args, proxy) -> {
            System.out.println("OrderService方法拦截：" + method.getName());
            return proxy.invokeSuper(obj, args);
        });
        OrderService proxyService = (OrderService) enhancer.create();
        return proxyService.getOrderInfo(id);
    }

    // 业务类
    static class OrderService {
        public String getOrderInfo(Long id) {
            return "Order-" + id;
        }
    }
}

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class OrderController {
    // 静态代理类实例，全局复用，避免重复生成
    private static final OrderService PROXY_SERVICE;

    // 初始化时生成一次代理类，后续请求复用实例
    static {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(OrderService.class);
        enhancer.setCallback((MethodInterceptor) (obj, method, args, proxy) -> {
            System.out.println("OrderService方法拦截：" + method.getName());
            return proxy.invokeSuper(obj, args);
        });
        PROXY_SERVICE = (OrderService) enhancer.create();
    }

    @GetMapping("/order/{id}")
    public String getOrder(@PathVariable Long id) {
        // 复用全局代理实例，不再生成新类
        return PROXY_SERVICE.getOrderInfo(id);
    }

    static class OrderService {
        public String getOrderInfo(Long id) {
            return "Order-" + id;
        }
    }
}

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

@RestController
public class FileUploadController {
    @PostMapping("/upload")
    public String uploadFile(@RequestParam("file") MultipartFile file) throws IOException {
        // 问题点：分配直接内存后未释放，直接内存持续堆积
        ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024 * 1024 * 10); // 10MB直接内存
        try (FileChannel channel = FileChannel.open(Paths.get("/Users/xxx/upload/" + file.getOriginalFilename()), 
   China编程             StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
            // 读取文件内容到直接内存缓冲区
            int readBytes;
            while ((readBytes = file.getInputStream().read(directBuffer.array())) != -1) {
                directBuffer.flip();
                channel.write(directBuffer);
                // 未调用clear()重置缓冲区，直接内存无法被回收
            }
            return "文件上传成功：" + file.getOriginalFilename();
        }
        // 直接Buffer未手动释放，且未触发GC时，直接内存占用持续保留
    }
}

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

@RestController
public class FileUploadController {
    // 复用直接Buffer：通过静态变量缓存，避免频繁分配
    private static final ByteBuffer DIRECT_BUFFER = ByteBuffer.allocateDirect(1024 * 1024 * 10); // 10MB直接内存

    @PostMapping("/upload")
    public String uploadFile(@RequestParam("file") MultipartFile file) throws IOException {
        try (FileChannel channel = FileChannel.open(Paths.get("/Users/xxx/upload/" + file.getOriginalFilename()), 
                StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
   http://www.chinasem.cn         int readBytes;
            // 加锁确保多线程下Buffer复用安全（实际生产可使用更高效的池化方案）
            synchronized (DIRECT_BUFFER) {
                while ((readBytes = file.getInputStream().read(DIRECT_BUFFER.array())) != -1) {
                    DIRECT_BUFFER.flip(); // 切换为读模式
                    channel.write(DIRECT_BUFFER);
                    DIRECT_BUFFER.clear(); // 关键：重置缓冲区，释放直接内存占用
                }
            }
            return "文件上传成功：" + file.getOriginalFilename();
        }
    }
}

@Service
public class OrderDiscountService {
    /**
     * 递归计算订单折扣（问题：终止条件错误，discount <= 0 时仍继续递归）
     * @param originalPrice 订单原价
     * @param discount 当前折扣比例（初始值0.9，每次递归减0.1）
     * @return 折扣后价格
     */
    public double calculateDiscount(double originalPrice, double discount) {
        // 错误终止条件：应改为 discount <= 0 时返回 originalPrice，此处写成 discount >= 0，导致无限递归
        if (discount >= 0) {
            return originalPrice * discount;
        }
        // 递归调用：折扣比例每次减0.1，无终止条件时无限递归
        return calculateDiscount(originalPrice, discount - 0.1);
    }

    // 业务调用：初始折扣0.9，触发无限递归
    public double getFinalPrice(double originalPrice) {
        return calculateDiscount(originalPrice, 0.9);
    }
}

@Service
public class OrderDiscountService {
    /**
     * 修复：修正递归终止条件，discount <= 0 时返回原价
     */
    public double calculateDiscount(double originalPrice, double discount) {
        // 正确终止条件：折扣比例<=0时，返回原价（无折扣）
        if (discount <= 0) {
            return originalPrice;
        }
        // 递归调用：折扣比例每次减0.1，直至<=0终止
        return calculateDiscount(originalPrice, discount - 0.1);
    }

    // 业务调用：初始折扣0.9，递归5次后discount=0.4，继续递归至discount<=0终止
    public double getFinalPrice(double originalPrice) {
        return calculateDiscount(originalPrice, 0.9);
    }

    // 优化方案：改用迭代实现，彻底避免栈溢出风险
    public double calculateDiscountByIteration(double originalPrice, double discount) {
        double currentDiscount = discount;
        while (currentDiscount > 0) {
            originalPrice *= currentDiscount;
            currentDiscount -= 0.1;
        }
        return originalPrice;
    }
}

# JVM堆内存配置：初始堆内存(-Xms)与最大堆内存(-Xmx)保持一致，避免频繁扩容
-Xms4g -Xmx4g
# 新生代内存配置：占堆内存的1/3~1/2，根据对象存活周期调整
-XX:NewSize=1536m -XX:MaxNewSize=1536m
# 元空间配置：最大元空间(-XX:MaxMetaspaceSize)设为512m，避免元空间溢出
-XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=512m
# 直接内存配置：与堆内存保持一致，或根据NIO使用场景调整
-XX:MaxDirectMemorySize=4g
# 线程栈空间：默认1M，根据递归深度调整，避免StackOverflowError
-Xss1m
# OOM时自动生成堆快照：无需手动执行jmap，方便事后分析
-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/Users/xxx/heapdump/
# GC日志配置：记录GC详情，便于分析内存增长与GC效率
-XX:+PrintGCDetails -XX:+PrintGCDateStamps -Xloggc:/Users/xxx/gc.log