在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(caffeine.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
        system.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());
    }
}