<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.10</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

<properties>
    <java.version>11</java.version>
</properties>

<dependencies>
    <!-- Spring Boot Web核心依賴 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Jedis Redis客戶端 -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>3.8.0</version>
    </dependency>
    <!-- 內(nèi)存池依賴 -->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
        <version>2.11.1</version>
    </dependency>
</dependencies>

import redis.clients.jedis.Jedis;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.nio.ByteBuffer;
import java.util.List;

@RestController
public class ProductCacheController {

    // 商品數(shù)據(jù)獲取接口，模擬從Redis批量讀取數(shù)據(jù)并存儲到堆外內(nèi)存
    @GetMapping("/products")
    public String getProducts() {
        try (Jedis jedis = new Jedis("localhost", 6379)) {
            // 從Redis獲取商品列表數(shù)據(jù)，假設(shè)存儲在"product_list"鍵中
            List<String> productList = jedis.lrange("product_list", 0, -1);
            System.out.println("獲取到" + productList.size() + "條商品數(shù)據(jù)");
            
            // 為每條商品數(shù)據(jù)分配堆外內(nèi)存
            for (String product : productList) {
                // 使用allocateDirect分配直接內(nèi)存，這部分內(nèi)存不在JVM堆內(nèi)
                ByteBuffer directBuffer = ByteBuffer.allocateDirect(product.getBytes().length);
                // 將商品數(shù)據(jù)寫入堆外內(nèi)存
                directBuffer.put(product.getBytes());
                // 關(guān)鍵問題：此處未釋放分配的堆外內(nèi)存！
                // 隨著請求頻繁調(diào)用，內(nèi)存會持續(xù)泄漏
            }
            
            return "Products retrieved successfully, count: " + productList.size();
        }
    }
}

top - 20:30:20 up 10 days, 23:45,  2 users,  load average: 2.56, 2.48, 2.37
Tasks: 246 total,   1 running, 245 sleeping,   0 stopped,   0 zombie
%Cpu(s):  3.2 us,  1.1 sy,  0.0 ni, 95.4 id,  0.0 wa,  0.0 hi,  0.3 si,  0.0 st
KiB Mem : 16384892 total,  123456 free, 15890740 used,  360686 buff/cache
KiB Swap: 2097148 total,        0 free, 2097148 used.  123456 avail Mem 

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND
56789 root      20   0  4321456 3890740   1236 S  23.5 24.9  34:56.78 java

# 假設(shè)通過jps命令獲取到的進(jìn)程ID為56789
jstat -gcutil 56789 1000

  S0     S1     E      O      M     CCS    YGC     YGCT    FGC    FGCT     GCT   
  0.00  12.34  89.56  76.23  98.76  97.45    123    12.34     5     5.67    18.01
  0.00  15.67  90.12  76.23  98.76  97.45    123    12.34     5     5.67    18.01
  0.00  18.90  91.23  76.23  98.76  97.45    123    12.34     5     5.67    18.01

top

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND
56789 root      20   0  4321456 3890740   1236 S  23.5 24.9  34:56.78 java

jstat -gcutil 56789 1000

pmap 56789

56789:   java -jar product-cache-service.jar
0000000000400000      44K r-x-- java
000000000060a000       4K r---- java
000000000060b000       8K rw--- java
0000000001000000    10240K rw---   [heap]
...
00007f2a9c000000    20480K rw---   [direct map]
00007f2a9d500000    20480K rw---   [direct map]
00007f2a9ea00000    20480K rw---   [direct map]
...
00007f2b4c000000    20480K rw---   [direct map]

strace -f -e "brk,mmap,munmap" -p 56789

mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f2a9c000000
mmap(NULL, 20971520, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f2a9d500000
brk(0x1001000)                           = 0x1001000
mmap(NULL, 20971520, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f2a9ea00000
... (持續(xù)輸出mmap調(diào)用，沒有對應(yīng)的munmap)

jmap -histo:live 56789 | head -20

 num     #instances         #bytes  class name
----------------------------------------------
   1:        123456      245760000  java.nio.DirectByteBuffer
   2:         67890       8912640  [B
   3:         12345       4567800  java.lang.String

import redis.clients.jedis.Jedis;
import sun.misc.Cleaner;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import java.util.List;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductCacheController {

    @GetMapping("/products")
    public String getProducts() {
        try (Jedis jedis = new Jedis("localhost", 6379)) {
            List<String> productList = jedis.lrange("product_list", 0, -1);
            System.out.println("獲取到" + productList.size() + "條商品數(shù)據(jù)");
            
            for (String product : productList) {
                ByteBuffer directBuffer = ByteBuffer.allocateDirect(product.getBytes().length);
                directBuffer.put(product.getBytes());
                // 關(guān)鍵修改：顯式釋放堆外內(nèi)存
                cleanDirectBuffer(directBuffer);
            }
            
            return "Products retrieved successfully, count: " + productList.size();
        }
    }
    
    /**
     * 顯式釋放DirectByteBuffer占用的堆外內(nèi)存
     * 通過反射獲取Cleaner對象并執(zhí)行clean操作
     * 注意：這種方式依賴Sun內(nèi)部API，可能在不同JDK版本中變化
     */
    private static void cleanDirectBuffer(ByteBuffer buffer) {
        try {
            // 獲取ByteBuffer類中的cleaner字段
            Field cleanerField = buffer.getClass().getDeclaredField("cleaner");
            cleanerField.setAccessible(true);
            // 獲取Cleaner實(shí)例
            Cleaner cleaner = (Cleaner) cleanerField.get(buffer);
            // 執(zhí)行內(nèi)存清理
            cleaner.clean();
            System.out.println("釋放堆外內(nèi)存：" + buffer.capacity() + "字節(jié)");
        } catch (NoSuchFieldException | IllegalAccessException e) {
            System.err.println("內(nèi)存釋放失?。? + e.getMessage());
            e.printStackTrace();
        }
    }
}

import org.apache.commons.pool2.BasePooledObjectFactory;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import java.nio.ByteBuffer;

/**
 * 堆外內(nèi)存池管理類
 * 負(fù)責(zé)DirectByteBuffer對象的創(chuàng)建、回收和管理
 */
public class ByteBufferPool {

    // 默認(rèn)內(nèi)存池大小
    private static final int DEFAULT_INITIAL_SIZE = 100;
    private static final int DEFAULT_MAX_SIZE = 1000;
    private static final int DEFAULT_BLOCK_SIZE = 1024; // 1KB

    private GenericObjectPool<ByteBuffer> objectPool;

    public ByteBufferPool() {
        this(DEFAULT_INITIAL_SIZE, DEFAULT_MAX_SIZE, DEFAULT_BLOCK_SIZE);
    }

    /**
     * 自定義參數(shù)的內(nèi)存池構(gòu)造函數(shù)
     * @param initialSize 初始池大小
     * @param maxSize 最大池大小
     * @param blockSize 每個ByteBuffer的默認(rèn)大小(字節(jié))
     */
    public ByteBufferPool(int initialSize, int maxSize, int blockSize) {
        GenericObjectPoolConfig config = new GenericObjectPoolConfig();
        config.setInitialSize(initialSize);
        config.setMaxTotal(maxSize);
        config.setMaxIdle(maxSize);
        config.setMinIdle(initialSize / 2);
        config.setBlockWhenExhausted(true);
        config.setMaxWaitMillis(5000); // 超時時間5000ms
        
        objectPool = new GenericObjectPool<>(new ByteBufferFactory(blockSize), config);
        System.out.println("ByteBufferPool初始化完成，初始大小：" + initialSize + 
                          "，最大大小：" + maxSize + "，塊大?。? + blockSize + "字節(jié)");
    }

    /**
     * 從內(nèi)存池獲取ByteBuffer對象
     */
    public ByteBuffer borrowObject() throws Exception {
        ByteBuffer buffer = objectPool.borrowObject();
        // 清空緩沖區(qū)以便重用
        buffer.clear();
        return buffer;
    }

    /**
     * 將ByteBuffer對象歸還到內(nèi)存池
     */
    public void returnObject(ByteBuffer buffer) {
        try {
            objectPool.returnObject(buffer);
        } catch (Exception e) {
            System.err.println("歸還內(nèi)存池失?。? + e.getMessage());
        }
    }

    /**
     * 關(guān)閉內(nèi)存池
     */
    public void close() {
        try {
            objectPool.close();
            System.out.println("ByteBufferPool已關(guān)閉");
        } catch (Exception e) {
            System.err.println("關(guān)閉內(nèi)存池失敗：" + e.getMessage());
        }
    }

    /**
     * ByteBuffer對象工廠，負(fù)責(zé)創(chuàng)建新的ByteBuffer實(shí)例
     */
    private static class ByteBufferFactory extends BasePooledObjectFactory<ByteBuffer> {
        private final int blockSize;

        public ByteBufferFactory(int blockSize) {
            this.blockSize = blockSize;
        }

        @Override
        public ByteBuffer create() throws Exception {
            // 使用allocateDirect創(chuàng)建堆外內(nèi)存
            return ByteBuffer.allocateDirect(blockSize);
        }

        @Override
        public PooledObject<ByteBuffer> wrap(ByteBuffer byteBuffer) {
            return new DefaultPooledObject<>(byteBuffer);
        }

        @Override
        public void destroyObject(PooledObject<ByteBuffer> p) throws Exception {
            // 銷毀對象時釋放堆外內(nèi)存
            ByteBuffer buffer = p.getObject();
            cleanDirectBuffer(buffer);
            super.destroyObject(p);
        }

        @Override
        public boolean validateObject(PooledObject<ByteBuffer> p) {
            // 驗(yàn)證對象是否可用
            ByteBuffer buffer = p.getObject();
            return buffer != null && buffer.capacity() == blockSize;
        }
    }

    /**
     * 釋放DirectByteBuffer的堆外內(nèi)存
     */
    private static void cleanDirectBuffer(ByteBuffer buffer) {
        try {
            if (buffer == null) {
                return;
            }
            Field cleanerField = buffer.getClass().getDeclaredField("cleaner");
            cleanerField.setAccessible(true);
            Cleaner cleaner = (Cleaner) cleanerField.get(buffer);
            cleaner.clean();
        } catch (Exception e) {
            System.err.println("釋放堆外內(nèi)存失?。? + e.getMessage());
        }
    }
}

import redis.clients.jedis.Jedis;
import java.nio.ByteBuffer;
import java.util.List;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductCacheController {

    // 創(chuàng)建全局內(nèi)存池實(shí)例，初始大小100，最大大小1000，塊大小4KB
    private static final ByteBufferPool byteBufferPool = new ByteBufferPool(100, 1000, 4096);

    @GetMapping("/products")
    public String getProducts() {
        try (Jedis jedis = new Jedis("localhost", 6379)) {
            List<String> productList = jedis.lrange("product_list", 0, -1);
            System.out.println("獲取到" + productList.size() + "條商品數(shù)據(jù)，開始處理...");
            
            for (String product : productList) {
                ByteBuffer buffer = null;
                try {
                    // 從內(nèi)存池獲取ByteBuffer
                    buffer = byteBufferPool.borrowObject();
                    // 確保有足夠空間存儲數(shù)據(jù)
                    if (product.getBytes().length > buffer.capacity()) {
                        System.out.println("數(shù)據(jù)大小超出內(nèi)存池塊大小，臨時分配內(nèi)存");
                        // 特殊情況處理：數(shù)據(jù)過大時臨時分配
                        buffer = ByteBuffer.allocateDirect(product.getBytes().length);
                    }
                    buffer.put(product.getBytes());
                    // 這里可以添加數(shù)據(jù)處理邏輯
                    // ...
                } catch (Exception e) {
                    System.err.println("處理商品數(shù)據(jù)時發(fā)生異常：" + e.getMessage());
                    e.printStackTrace();
                } finally {
                    // 確保歸還到內(nèi)存池，即使發(fā)生異常
                    if (buffer != null && buffer.capacity() == byteBufferPool.getClass().getDeclaredField("DEFAULT_BLOCK_SIZE").getInt(null)) {
                        byteBufferPool.returnObject(buffer);
                    } else if (buffer != null) {
                        // 臨時分配的內(nèi)存需要顯式釋放
                        ByteBufferPool.cleanDirectBuffer(buffer);
                    }
                }
            }
            
            return "Products processed successfully, count: " + productList.size();
        } catch (Exception e) {
            System.err.println("接口處理異常：" + e.getMessage());
            return "Error: " + e.getMessage();
        }
    }
}

# 在啟動命令中添加以下參數(shù)
java -jar -Xmx2g -Xms2g -XX:MaxDirectMemorySize=1g product-cache-service.jar

import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Timer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import java.nio.ByteBuffer;
import java.util.List;
import java.util.concurrent.TimeUnit;

@Component
public class ProductCacheService {

    private final MeterRegistry meterRegistry;
    private final ByteBufferPool byteBufferPool;

    @Autowired
    public ProductCacheService(MeterRegistry meterRegistry, ByteBufferPool byteBufferPool) {
        this.meterRegistry = meterRegistry;
        this.byteBufferPool = byteBufferPool;
    }

    public List<String> getProductList() {
        // 記錄接口調(diào)用耗時
        Timer timer = Timer.start(meterRegistry);
        try (Jedis jedis = new Jedis("localhost", 6379)) {
            List<String> productList = jedis.lrange("product_list", 0, -1);
            // 記錄獲取到的商品數(shù)量
            meterRegistry.gauge("product.cache.count", productList.size());
            return productList;
        } finally {
            timer.stop(meterRegistry.timer("product.cache.get.time", "unit", "ms"));
        }
    }

    public void processWithBuffer(String productData) {
        ByteBuffer buffer = null;
        try {
            buffer = byteBufferPool.borrowObject();
            // 記錄內(nèi)存池使用情況
            meterRegistry.gauge("bytebuffer.pool.usage", byteBufferPool, 
                pool -> pool.objectPool.getNumActive() + "/" + pool.objectPool.getMaxTotal());
            
            if (productData.getBytes().length > buffer.capacity()) {
                meterRegistry.counter("bytebuffer.pool.overflow").increment();
                // 處理大對象情況...
            }
        } catch (Exception e) {
            meterRegistry.counter("product.process.error").increment();
        } finally {
            if (buffer != null) {
                byteBufferPool.returnObject(buffer);
            }
        }
    }
}

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class MemoryLeakTest {

    private ExecutorService executorService;
    private List<ByteBuffer> bufferList;

    @BeforeEach
    void setUp() {
        executorService = Executors.newFixedThreadPool(20);
        bufferList = new ArrayList<>();
    }

    @AfterEach
    void tearDown() throws Exception {
        executorService.shutdown();
        executorService.awaitTermination(5, TimeUnit.SECONDS);
        
        // 顯式釋放測試中創(chuàng)建的buffer
        for (ByteBuffer buffer : bufferList) {
            if (buffer != null) {
                // 釋放堆外內(nèi)存
                ByteBufferPool.cleanDirectBuffer(buffer);
            }
        }
    }

    @Test
    void testHeapOutOfMemory() throws Exception {
        // 模擬1000次并發(fā)請求
        CountDownLatch latch = new CountDownLatch(1000);
        
        for (int i = 0; i < 1000; i++) {
            executorService.submit(() -> {
                try {
                    // 這里模擬業(yè)務(wù)代碼中的堆外內(nèi)存使用
                    ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024); // 1MB
                    bufferList.add(buffer);
                    // 模擬業(yè)務(wù)處理
                    Thread.sleep(10);
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    // 測試中必須顯式釋放，避免影響其他測試
                    ByteBufferPool.cleanDirectBuffer(bufferList.remove(bufferList.size() - 1));
                    latch.countDown();
                }
            });
        }
        
        // 等待所有任務(wù)完成
        latch.await(30, TimeUnit.SECONDS);
        
        // 驗(yàn)證內(nèi)存是否正確釋放
        System.gc();
        Thread.sleep(1000);
        
        // 可以在此處添加內(nèi)存使用情況的驗(yàn)證邏輯
        // 例如通過ManagementFactory獲取內(nèi)存信息
    }
}