在Spring Boot中浅尝内存泄漏的实战记录

package io.renren.controller;
import org.springframework.boot.SpringApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import java.util.ArrayList;
import java.util.List;
/**
 * author: lj
 * date: 2025-4
 */
@RestController
public class MemoryLeakController {
    // 静态集合会持续持有对象引用
    private static List<byte[]> LEAKING_LIST = new ArrayList<>();
    // 内存泄漏端点
    @GetMapping("/leak")
    public String leakMemory() {
        // 每次请求添加1MB数据（不会被释放）
        LEAKING_LIST.add(new byte[1024 * 1024]);
        return "已泄漏内存: " + LEAKING_LIST.size() + " MB";
    }
    // 触发OOM的测试方法（快速验证）
    public static void main(String[] args) throws InterruptedException {
        SpringApplication.run(MemoryLeakController.class, args);
        // 通过循环请求快速触发OOM
        while(true) {
            new RestTemplate().getForObject("http://localhost:8080/leak", String.class);
            Thread.sleep(100);
        }
    }
}

//在cmd中先cd到jar包所在目录，执行如下命令启动
//-Xmx100m 当程序需要更多内存时，JVM会尝试分配最多100MB的堆内存。如果超过这个限制，可能会抛出OutOfMemoryError
//-Xms100m JVM在启动时分配的最小内存量。如果初始堆内存设置得过低，程序可能在运行过程中频繁扩展堆内存，影响性能。
//-XX:+HeapDumpOnOutOfMemoryError 在发生OutOfMemoryError时生成堆转储（Heap Dump）的功能
java -jar -Xmx100m -Xms100m -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=D:\Temp renren-generator-1.0.0.jar

@Scheduled(fixedRate = 60_000)
public void cleanLeakingData() {
    LEAKING_LIST.removeIf(data -> /* 清理条件 */);
}

@SpringBootApplication
@RestController
@EnableCaching // 关键注解：启用缓存
public class CacheLeakDemo {
    // 模拟缓存未正确清理
    @Cacheable("leakyCache")
    @GetMapping("/cache-leak")
    public byte[] cacheLeak() {
        return new byte[1024 * 1024]; // 每次缓存1MB
    }
    public static void main(String[] args) {
        SpringApplication.run(CacheLeakDemo.class, args);
    }
}

// 使用WeakHashMap解决
private static Map<byte[], Boolean> SAFE_MAP = 
    Collections.synchronizedMap(new WeakHashMap<>());

// 使用Caffeine缓存并设置上限
@Bean
public CacheManager cacheManager() {
    CaffeineCacheManager manager = new CaffeineCacheManager();
    manager.setCaffeine(androidCaffeine.newBuilder()
            .maximumSize(100)
            .expireAfterWrite(10, TimeUnit.MINUTES));
    return manager;
}

//使用普通HashMap导致泄漏
public class LeakingCache {
    private static Map<byte[], String> CACHE = new HashMap<>();
    // 添加大对象到缓存
    public static void addToCache(byte[] key, String value) {
        CACHE.put(key, value);
    }
    public static void main(String[] args) {
        // 模拟添加后不再使用key
        byte[] key = new byte[1024 * 1024]; // 1MB
        addToCache(key, "大数据");
        key = null; // 删除强引用
        // 触发GC
        Systandroidem.gc();
        // 缓存仍然持有key的强引用，导致1MB内存无法回收
        System.out.println("缓存大小: " + CACHE.size()); // 输出1
    }
}

//使用WeakHashMap
public class SafeCache {
    // 使用WeakHashMap + 同步包装（线程安全）
    private static Map<byte[], String> SAFE_CACHE = 
        Collections.synchronizedMap(new WeakHashMap<>());
    public static void addToCache(byte[] key, String value) {
        SAFE_CACHE.put(key, value);
    }
    public static void main(String[] args) {
        byte[] key = new byte[1024 * 1024];
        addToCache(key, "安全数据");
        key = null; // 删除最后一个强引用
        // 强制GC（生产环境不要主动调用System.gc()）
        System.gc();
        // 给GC一点时间执行
        try { Thread.sleep(1000); } catch (InterruptedException e) {}
        System.out.println("缓存大小: " + SAFE_CACHE.size()); // 输出0
    }
}

@RestController
public class DeviceController {
    // 使用WeakHashMap管理临时会话
    private static Map<Device, Session> deviceSessions = 
        Collections.synchronizedMap(new WeakHashMap<>());
    @PostMapping("/connect")
    public String connect(@RequestBody Device device) {
        Session session = new Session(device);
        deviceSessions.put(device, session);
        return "Connected";
    }
    // 当Device对象不再被外部引用时，自动清理会话
}

@GetMapping("/session-count")
public int getSessionCount() {
    return deviceSessions.size();
}

1，发送连接请求
curl -X POST http://localhost:8080/connect -d '{"id":"device1"}'
2，立即调用/session-count查看数量
3，停止持有Device对象引用后触发GC
4，再次检查会话数量

public class AdvancedCache<K, V> {
    private final Map<K, V> cache = 
        new WeakHashMap<>();
    private final ReferenceQueue<K> queue = 
        new ReferenceQueue<>();
    public void put(K key, V value) {
        // 清理已回收的条目
        processQueue();
        cache.put(key, value);
    }
    private void processQueue() {
        Reference<? extends K> ref;
        while ((ref = queue.poll()) != null) {
            // 这里可以触发回调清理相关资源
            System.out.println("清理条目: " + ref);
        }
    }
}

// 测试插入100万条数据
IntStream.range(0, 1_000_000).forEach(i -> {
    Object key = new Object();
    map.put(key, "Value-" + i);
});
// 强制GC后统计剩余条目
System.gc();
Thread.sleep(1000);
System.out.println("剩余条目: " + map.size());

public class DeviceStateManager {
    // Key: 设备对象，Value: 最后上报时间
    private final WeakHashMap<Device, Long> lastReportTime = 
        new WeakHashMap<>();
    // 更新状态
    public void updateState(Device device) {
        lastReportTime.put(device, System.currentTimeMillis());
    }
    // 获取在线设备列表（需配合ReferenceQueue清理）
    public List<Device> getOnlineDevices() {
        return new ArrayList<>(lastReportTime.keySet());
    }
}