CPU 打满 + 频繁 Full GC：从紧急止血到根因根治的实战指南

# 重启服务并在OOM时生成内存快照（路径：/tmp/heapdump.hprof）java -jar your-service.jar -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/tmp/heapdump.hprof

 S0C    S1C    S0U    S1U      EC       EU        OC         OU       MC     MU    CCSC   CCSU   YGC     YGCT    FGC    FGCT     GCT   2048.0 2048.0  0.0   2048.0 16384.0  16384.0   32768.0    32768.0   10240.0 9216.0 1024.0  896.0    120    0.600   50     12.500   13.100

# 生成进程ID为12345的内存快照，保存到/tmp目录jmap -dump:format=b,file=/tmp/heapdump-$(date +%Y%m%d).hprof 12345

# 查看进程12345的存活对象，按大小排序，取前20jmap -histo:live 12345 | sort -k 3 -n -r | head -20

# 启动jhat服务，分析快照文件，端口7000jhat -port 7000 /tmp/heapdump.hprof

# 跟踪com.xxx.DataService类的process方法，查看是否创建大对象trace com.xxx.DataService process -n 5

jinfo -flags 12345# 输出中若有-XX:+UseSerialGC（Serial收集器）、-Xmx4g（堆内存4GB），需结合服务需求判断是否合理

# 查看进程12345中，16进制线程ID为0x3039的线程栈jstack 12345 | grep -A 20 0x3039

"Thread-0" #10 prio=5 os_prio=0 cpu=999999999 elapsed=3600.00s tid=0x00007f1234567890 nid=0x3039 runnable [0x00007f1234560000]   java.lang.Thread.State: RUNNABLE        at com.xxx.DataHandler.process(DataHandler.java:45)        at com.xxx.DataHandler.run(DataHandler.java:20)        at java.lang.Thread.run(Thread.java:748)

# 启动CPU采样，持续30秒，生成火焰图profiler start -d 30# 采样结束后生成HTML格式火焰图profiler stop --format html

// 优化前：静态HashMap无清理机制，对象持续堆积public class GlobalCache {    public static Map<String, UserData> userCache = new HashMap<>();    // 只存不删的put方法    public static void putUser(String userId, UserData data) {        userCache.put(userId, data);    }}// 优化后：WeakHashMap+定时清理+过期时间public class GlobalCache {    // WeakHashMap：对象无其他强引用时自动回收    private static Map<String, ExpiredData<UserData>> userCache = new WeakHashMap<>();    // 过期时间：24小时（可配置化）    private static final long EXPIRE_TIME = 24 * 60 * 60 * 1000L;    // 存入时记录时间戳    public static void putUser(String userId, UserData data) {        ExpiredData<UserData> expiredData = new ExpiredData<>(data, System.currentTimeMillis());        userCache.put(userId, expiredData);    }    // 获取时校验是否过期    public static UserData getUser(String userId) {        ExpiredData<UserData> expiredData = userCache.get(userId);        if (expiredData == null) {            return null;        }        // 过期数据直接删除并返回null        if (System.currentTimeMillis() - expiredData.getTimestamp() > EXPIRE_TIME) {            userCache.remove(userId);            return null;        }        return expiredData.getData();    }    // 定时任务：每天凌晨清理所有过期数据（兜底）    @Scheduled(cron = "0 0 0 * * ?")    public void cleanExpiredData() {        long currentTime = System.currentTimeMillis();        userCache.entrySet().removeIf(entry ->             currentTime - entry.getValue().getTimestamp() > EXPIRE_TIME        );        log.info("清理过期缓存数据，剩余缓存量：{}", userCache.size());    }    // 过期数据包装类    @Data    private static class ExpiredData<T> {        private T data;        private long timestamp; // 存入时间戳        // 构造方法省略    }}

// 优化前：手动关闭流，易遗漏（如异常时未执行close()）public void readFile(String path) {    FileInputStream fis = null;    try {        fis = new FileInputStream(path);        // 读取逻辑    } catch (IOException e) {        log.error("读取文件异常", e);    } finally {        if (fis != null) {            try {                fis.close(); // 若前面抛异常，此处可能未执行            } catch (IOException e) {                log.error("关闭流异常", e);            }        }    }}// 优化后：try-with-resources自动关闭资源（实现AutoCloseable接口的类均可使用）public void readFile(String path) {    try (FileInputStream fis = new FileInputStream(path)) {        // 读取逻辑    } catch (IOException e) {        log.error("读取文件异常", e);    }    // 无需手动关闭，try块结束后自动调用fis.close()}

spring:  datasource:    hikari:      idle-timeout: 600000 # 10分钟未使用的连接自动回收      max-lifetime: 1800000 # 连接最大生命周期30分钟，避免资源泄漏

// 示例：byte[]对象池，复用100MB的数组public class ByteArrayPool {    // 配置对象池：最大空闲3个，最大总数10个    private final GenericObjectPool<byte[]> pool;    public ByteArrayPool() {        GenericObjectPoolConfig<byte[]> config = new GenericObjectPoolConfig<>();        config.setMaxIdle(3); // 最大空闲对象数        config.setMaxTotal(10); // 池内最大对象总数        config.setMinEvictableIdleTimeMillis(300000); // 5分钟未使用的对象自动回收        // 工厂：创建100MB的byte[]        PooledObjectFactory<byte[]> factory = new BasePooledObjectFactory<byte[]>() {            @Override            public byte[] create() {                return new byte[1024 * 1024 * 100]; // 100MB            }            @Override            public PooledObject<byte[]> wrap(byte[] obj) {                return new DefaultPooledObject<>(obj);            }            // 归还时清空数组（避免数据残留）            @Override            public void passivateObject(PooledObject<byte[]> p) {                Arrays.fill(p.getObject(), (byte) 0);            }        };        this.pool = new GenericObjectPool<>(factory, config);    }    // 从池获取对象    public byte[] borrow() throws Exception {        return pool.borrowObject();    }    // 归还对象到池    public void returnObject(byte[] obj) {        if (obj != null) {            pool.returnObject(obj);        }    }}// 使用方式public class DataService {    private final ByteArrayPool byteArrayPool = new ByteArrayPool();    public void processLargeData() {        byte[] buffer = null;        try {            buffer = byteArrayPool.borrow(); // 复用对象，而非new            // 处理大文件/大缓存逻辑        } catch (Exception e) {            log.error("处理大数据异常", e);        } finally {            byteArrayPool.returnObject(buffer); // 归还对象，供下次复用        }    }}

// 优化前：一次性创建100MB的byte[]（直接进入老年代）public byte[] generateLargeData() {    byte[] largeData = new byte[1024 * 1024 * 100]; // 100MB    // 填充数据逻辑    return largeData;}// 优化后：拆分为10个10MB的小对象，处理后合并（小对象在年轻代回收）public byte[] generateLargeData() {    List<byte[]> smallParts = new ArrayList<>();    try {        // 拆分：创建10个10MB的小数组        for (int i = 0; i < 10; i++) {            byte[] smallPart = new byte[1024 * 1024 * 10]; // 10MB            // 填充当前分片的数据            fillData(smallPart, i);            smallParts.add(smallPart);        }        // 合并小对象（按需合并，避免再次创建大对象）        return mergeSmallParts(smallParts);    } finally {        // 主动清空引用，帮助GC回收小对象        smallParts.clear();    }}// 合并小数组（按需使用，避免长期持有）private byte[] mergeSmallParts(List<byte[]> parts) {    int totalLength = parts.stream().mapToInt(arr -> arr.length).sum();    byte[] result = new byte[totalLength];    int destPos = 0;    for (byte[] part : parts) {        System.arraycopy(part, 0, result, destPos, part.length);        destPos += part.length;    }    return result;}

-Xms16g -Xmx16g -XX:+UseParallelGC -XX:+UseParallelOldGC -XX:ParallelGCThreads=8 -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/tmp/heapdump.hprof

// 优化前：死循环（无退出条件，index未递增，永远处理第一个元素）public void processData(List<Data> dataList) {    int index = 0;    while (true) {        Data data = dataList.get(index);        handleData(data); // 重复处理第一个元素，CPU持续100%    }}// 优化后：三重保障（边界退出+超时退出+异常捕获）public void processData(List<Data> dataList) {    // 1. 防御性判断：避免空列表/空元素导致的间接循环    if (CollectionUtils.isEmpty(dataList)) {        log.warn("待处理数据列表为空，直接返回");        return;    }    int index = 0;    long startTime = System.currentTimeMillis();    // 2. 边界退出条件：处理完所有元素后终止循环    while (index < dataList.size()) {        Data data = dataList.get(index);        try {            handleData(data);             index++; // 关键：处理完成后递增索引，避免重复处理        } catch (Exception e) {            // 3. 异常捕获：单个元素处理失败不中断循环，仅记录日志            log.error("处理第{}条数据异常，dataId={}", index, data.getId(), e);            index++; // 异常时仍递增索引，防止卡在异常元素        }        // 4. 超时退出：避免未知异常导致的无限循环（如index被意外重置）        if (System.currentTimeMillis() - startTime > 30000) { // 30秒超时            log.error("数据处理超时，已处理{}条，总条数{}，强制终止", index, dataList.size());            alertService.sendAlert("【紧急】数据处理超时，可能存在死循环，已终止");            break;        }    }}

// 优化前：高频调用+重复查库+重复计算（CPU占用高，数据库压力大）@Servicepublic class PriceService {    @Autowired    private ProductDao productDao;    // 每秒调用1000次，productId重复率80%    public double calculateFinalPrice(String productId, int quantity, Long userId) {        // 1. 重复查库：相同productId每次都查数据库        Product product = productDao.getById(productId);        if (product == null) {            throw new BusinessException("商品不存在");        }        // 2. 重复计算：相同参数每次都执行复杂公式        double basePrice = product.getBasePrice();        double discount = calculateUserDiscount(userId); // 复杂计算：查用户等级、会员权益        return basePrice * quantity * (1 - discount);    }    // 复杂折扣计算（耗时50ms，CPU占用高）    private double calculateUserDiscount(Long userId) {        // 查用户等级、会员有效期、历史消费记录...        return 0.1; // 示例折扣：10%    }}// 优化后：Caffeine本地缓存+结果复用（CPU占用降低70%，数据库查询减少80%）@Servicepublic class PriceService {    @Autowired    private ProductDao productDao;    // 1. 商品信息缓存：key=productId，过期时间5分钟，最大容量1000条    private final LoadingCache<String, Product> productCache = Caffeine.newBuilder()            .expireAfterWrite(5, TimeUnit.MINUTES) // 5分钟过期（与商品更新频率匹配）            .maximumSize(1000) // 最大缓存1000个商品（避免内存溢出）            .recordStats() // 开启统计（便于监控缓存命中率）            .build(productId -> productDao.getById(productId)); // 缓存不存在时自动查库    // 2. 最终价格缓存：key=productId_quantity_userId，过期时间1分钟（折扣可能实时变化）    private final LoadingCache<String, Double> priceCache = Caffeine.newBuilder()            .expireAfterWrite(1, TimeUnit.MINUTES)            .maximumSize(10000)            .build(key -> {                // 解析key：格式为"productId_quantity_userId"                String[] parts = key.split("_");                String productId = parts[0];                int quantity = Integer.parseInt(parts[1]);                Long userId = Long.parseLong(parts[2]);                // 从商品缓存获取信息（避免重复查库）                Product product = productCache.get(productId);                // 计算折扣（若折扣也重复，可单独缓存折扣结果）                double discount = calculateUserDiscount(userId);                return product.getBasePrice() * quantity * (1 - discount);            });    // 对外提供的计算方法：优先从缓存获取    public double calculateFinalPrice(String productId, int quantity, Long userId) {        // 构建缓存key（确保参数唯一对应）        String cacheKey = String.format("%s_%d_%d", productId, quantity, userId);        try {            return priceCache.get(cacheKey);        } catch (Exception e) {            // 缓存获取失败时降级：直接计算（避免服务不可用）            log.error("获取价格缓存失败，key={}", cacheKey, e);            Product product = productDao.getById(productId);            double discount = calculateUserDiscount(userId);            return product.getBasePrice() * quantity * (1 - discount);        }    }    // 监控缓存命中率（暴露给Prometheus）    @Metric(name = "price_cache_hit_rate", description = "价格缓存命中率")    public double getPriceCacheHitRate() {        CacheStats stats = priceCache.stats();        return stats.hitRate(); // 命中率=命中次数/(命中次数+ miss次数)    }    // 复杂折扣计算（不变）    private double calculateUserDiscount(Long userId) { /* ... */ }}

// Redis缓存实现价格计算（多实例共享）@Servicepublic class PriceService {    @Autowired    private ProductDao productDao;    @Autowired    private StringRedisTemplate redisTemplate;    // Redis key前缀（避免key冲突）    private static final String PRODUCT_KEY_PREFIX = "product:info:";    private static final String PRICE_KEY_PREFIX = "price:final:";    // 过期时间（商品信息5分钟，价格1分钟）    private static final Duration PRODUCT_EXPIRE = Duration.ofMinutes(5);    private static final Duration PRICE_EXPIRE = Duration.ofMinutes(1);    public double calculateFinalPrice(String productId, int quantity, Long userId) {        // 1. 构建价格缓存key        String priceKey = PRICE_KEY_PREFIX + productId + "_" + quantity + "_" + userId;        // 2. 先查Redis缓存        String priceStr = redisTemplate.opsForValue().get(priceKey);        if (priceStr != null) {            return Double.parseDouble(priceStr);        }        // 3. 缓存未命中：查商品信息（Redis缓存）        String productKey = PRODUCT_KEY_PREFIX + productId;        String productStr = redisTemplate.opsForValue().get(productKey);        Product product;        if (productStr != null) {            product = JSON.parseObject(productStr, Product.class);        } else {            // 商品缓存未命中：查库并写入Redis            product = productDao.getById(productId);            redisTemplate.opsForValue().set(productKey, JSON.toJSONString(product), PRODUCT_EXPIRE);        }        // 4. 计算最终价格并写入Redis        double discount = calculateUserDiscount(userId);        double finalPrice = product.getBasePrice() * quantity * (1 - discount);        redisTemplate.opsForValue().set(priceKey, String.valueOf(finalPrice), PRICE_EXPIRE);        return finalPrice;    }    private double calculateUserDiscount(Long userId) { /* ... */ }}

// 优化前：循环中重复创建StringBuilder（每次循环都new，产生大量临时对象）public String concatUserIds(List<Long> userIds) {    String result = "";    for (Long userId : userIds) {        result += userId + ","; // 每次+=都会new StringBuilder，效率低    }    return result.substring(0, result.length() - 1); // 最后删除多余的逗号}// 优化后：提前创建单个StringBuilder，复用对象（减少90%临时对象创建）public String concatUserIds(List<Long> userIds) {    if (CollectionUtils.isEmpty(userIds)) {        return "";    }    // 提前估算容量（避免StringBuilder扩容消耗CPU）    StringBuilder sb = new StringBuilder(userIds.size() * 20);     for (int i = 0; i < userIds.size(); i++) {        sb.append(userIds.get(i));        if (i != userIds.size() - 1) {            sb.append(","); // 最后一个元素后不添加逗号，避免后续删除操作        }    }    return sb.toString();}

// 优化前：遍历全量列表找目标元素（即使找到也继续循环，浪费CPU）public User findUserById(List<User> userList, Long targetId) {    for (User user : userList) {        if (targetId.equals(user.getId())) {            // 找到目标但未终止循环，继续遍历剩余元素            return user;         }    }    return null;}// 优化后：使用迭代器+提前终止（找到后立即break，减少循环次数）// 进阶：若列表频繁查询，可转为HashMap（O(1)查询，替代O(n)遍历）public User findUserById(List<User> userList, Long targetId) {    // 方案A：遍历优化（适合列表较小，偶尔查询）    for (User user : userList) {        if (targetId.equals(user.getId())) {            return user; // 找到后立即返回，终止循环        }    }    // 方案B：转为HashMap（适合列表较大，频繁查询）    // 仅初始化一次（如服务启动时），避免每次查询都new HashMap    Map<Long, User> userMap = userList.stream()            .collect(Collectors.toMap(User::getId, Function.identity()));    return userMap.get(targetId); // O(1)查询，CPU消耗极低}

// 优化前：序列化全量字段（包含大量无用字段，消耗CPU与内存）public String getUserJson(User user) {    // User类包含id、name、age、password（敏感）、createTime等20个字段    // 接口仅需id、name、age，但序列化了所有字段    return JSON.toJSONString(user); }// 优化后：指定序列化字段（仅序列化必要字段，减少50%序列化耗时）public String getUserJson(User user) {    // 方案1：使用@JSONField(serialize = false)标记无需序列化的字段（如password）    // 方案2：手动构建JSON，仅包含必要字段（更灵活）    JSONObject json = new JSONObject();    json.put("id", user.getId());    json.put("name", user.getName());    json.put("age", user.getAge());    return json.toString();}