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 {
    // 靜態(tài)集合會(huì)持續(xù)持有對象引用
    private static List<byte[]> LEAKING_LIST = new ArrayList<>();
    // 內(nèi)存泄漏端點(diǎn)
    @GetMapping("/leak")
    public String leakMemory() {
        // 每次請求添加1MB數(shù)據(jù)（不會(huì)被釋放）
        LEAKING_LIST.add(new byte[1024 * 1024]);
        return "已泄漏內(nèi)存: " + LEAKING_LIST.size() + " MB";
    }
    // 觸發(fā)OOM的測試方法（快速驗(yàn)證）
    public static void main(String[] args) throws InterruptedException {
        SpringApplication.run(MemoryLeakController.class, args);
        // 通過循環(huán)請求快速觸發(fā)OOM
        while(true) {
            new RestTemplate().getForObject("http://localhost:8080/leak", String.class);
            Thread.sleep(100);
        }
    }
}

//在cmd中先cd到j(luò)ar包所在目錄，執(zhí)行如下命令啟動(dòng)
//-Xmx100m 當(dāng)程序需要更多內(nèi)存時(shí)，JVM會(huì)嘗試分配最多100MB的堆內(nèi)存。如果超過這個(gè)限制，可能會(huì)拋出OutOfMemoryError
//-Xms100m JVM在啟動(dòng)時(shí)分配的最小內(nèi)存量。如果初始堆內(nèi)存設(shè)置得過低，程序可能在運(yùn)行過程中頻繁擴(kuò)展堆內(nèi)存，影響性能。
//-XX:+HeapDumpOnOutOfMemoryError 在發(fā)生OutOfMemoryError時(shí)生成堆轉(zhuǎn)儲(chǔ)（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 -> /* 清理?xiàng)l件 */);
}

@SpringBootApplication
@RestController
@EnableCaching // 關(guān)鍵注解：啟用緩存
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緩存并設(shè)置上限
@Bean
public CacheManager cacheManager() {
    CaffeineCacheManager manager = new CaffeineCacheManager();
    manager.setCaffeine(Caffeine.newBuilder()
            .maximumSize(100)
            .expireAfterWrite(10, TimeUnit.MINUTES));
    return manager;
}

//使用普通HashMap導(dǎo)致泄漏
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, "大數(shù)據(jù)");
        key = null; // 刪除強(qiáng)引用
        // 觸發(fā)GC
        System.gc();
        // 緩存仍然持有key的強(qiáng)引用，導(dǎo)致1MB內(nèi)存無法回收
        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, "安全數(shù)據(jù)");
        key = null; // 刪除最后一個(gè)強(qiáng)引用
        // 強(qiáng)制GC（生產(chǎn)環(huán)境不要主動(dòng)調(diào)用System.gc()）
        System.gc();
        // 給GC一點(diǎn)時(shí)間執(zhí)行
        try { Thread.sleep(1000); } catch (InterruptedException e) {}
        System.out.println("緩存大小: " + SAFE_CACHE.size()); // 輸出0
    }
}

@RestController
public class DeviceController {
    // 使用WeakHashMap管理臨時(shí)會(huì)話
    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";
    }
    // 當(dāng)Device對象不再被外部引用時(shí)，自動(dòng)清理會(huì)話
}

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

1，發(fā)送連接請求
curl -X POST http://localhost:8080/connect -d '{"id":"device1"}'
2，立即調(diào)用/session-count查看數(shù)量
3，停止持有Device對象引用后觸發(fā)GC
4，再次檢查會(huì)話數(shù)量

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) {
            // 這里可以觸發(fā)回調(diào)清理相關(guān)資源
            System.out.println("清理?xiàng)l目: " + ref);
        }
    }
}

// 測試插入100萬條數(shù)據(jù)
IntStream.range(0, 1_000_000).forEach(i -> {
    Object key = new Object();
    map.put(key, "Value-" + i);
});
// 強(qiáng)制GC后統(tǒng)計(jì)剩余條目
System.gc();
Thread.sleep(1000);
System.out.println("剩余條目: " + map.size());

public class DeviceStateManager {
    // Key: 設(shè)備對象，Value: 最后上報(bào)時(shí)間
    private final WeakHashMap<Device, Long> lastReportTime = 
        new WeakHashMap<>();
    // 更新狀態(tài)
    public void updateState(Device device) {
        lastReportTime.put(device, System.currentTimeMillis());
    }
    // 獲取在線設(shè)備列表（需配合ReferenceQueue清理）
    public List<Device> getOnlineDevices() {
        return new ArrayList<>(lastReportTime.keySet());
    }
}