JVM内存结构深度解析：堆、栈、方法区、元空间、直接内存

/**
 * JVM内存区域特性详解
 */
public class JVMMemoryRegions {
    
    // 内存区域类型枚举
    public enum MemoryRegionType {
        HEAP("堆内存", true, true, "所有线程共享，GC主要区域"),
        STACK("虚拟机栈", false, false, "线程私有，存储栈帧"),
        METASPACE("元空间", true, true, "类元数据存储，JDK8+"),
        DIRECT("直接内存", false, true, "堆外内存，NIO使用");
        
        private final String name;
        private final boolean shared;    // 是否线程共享
        private final boolean gc;        // 是否受GC管理
        private final String description;
        
        MemoryRegionType(String name, boolean shared, boolean gc, String desc) {
            this.name = name;
            this.shared = shared;
            this.gc = gc;
            this.description = desc;
        }
    }
    
    // 内存区域大小配置示例
    public class MemoryConfiguration {
        // 堆内存配置
        private long heapSize = 1024 * 1024 * 1024; // 1G
        private long youngRatio = 3;                 // 新生代比例
        private long survivorRatio = 8;              // Survivor区比例
        
        // 元空间配置（JDK8+）
        private long metaspaceSize = 256 * 1024 * 1024;  // 256M
        private long maxMetaspaceSize = 512 * 1024 * 1024; // 512M
        
        // 栈内存配置
        private int stackSize = 1024 * 1024; // 1M per thread
        
        // 直接内存配置
        private long maxDirectMemory = 512 * 1024 * 1024; // 512M
    }
}

1.2 运行时数据区详细解析

/**
 * 运行时数据区深度分析
 */
public class RuntimeDataAreas {
    
    // 1. 程序计数器（Program Counter Register）
    public class ProgramCounter {
        // 特性：线程私有、无OOM、执行字节码行号指示器
        private volatile long currentAddress; // 当前指令地址
        
        public void executeMethod() {
            // 每个线程独立的程序计数器
            // 存储下一条要执行的字节码指令地址
        }
    }
    
    // 2. Java虚拟机栈（JVM Stack）
    public class JavaVirtualMachineStack {
        private final Stack<StackFrame> frames = new Stack<>();
        private final int maxDepth; // 栈深度限制
        
        // 栈帧结构
        public class StackFrame {
            // 局部变量表（Local Variables）
            private final Object[] localVariables;
            
            // 操作数栈（Operand Stack）
            private final Stack<Object> operandStack;
            
            // 动态链接（Dynamic Linking）
            private Method method;
            private Class<?> clazz;
            
            // 方法返回地址
            private int returnAddress;
            
            public StackFrame(Method method, int maxLocals, int stackSize) {
                this.method = method;
                this.localVariables = new Object[maxLocals];
                this.operandStack = new Stack<>();
            }
        }
        
        // 栈内存溢出模拟
        public void causeStackOverflow() {
            causeStackOverflow(); // 递归调用导致栈深度溢出
        }
    }
    
    // 3. 本地方法栈（Native Method Stack）
    public class NativeMethodStack {
        // 为Native方法服务，HotSpot将本地方法栈和虚拟机栈合二为一
    }
    
    // 4. Java堆（Heap）内存结构
    public class JavaHeap {
        private final YoungGeneration youngGen;  // 新生代
        private final OldGeneration oldGen;      // 老年代
        
        // 对象内存分配流程
        public Object allocateObject(Class<?> clazz) {
            // 1. 尝试在Eden区分配
            Object obj = youngGen.allocate(clazz);
            if (obj != null) return obj;
            
            // 2. 触发Minor GC后重试
            youngGen.minorGC();
            obj = youngGen.allocate(clazz);
            if (obj != null) return obj;
            
            // 3. 尝试老年代分配
            obj = oldGen.allocate(clazz);
            if (obj != null) return obj;
            
            // 4. 触发Full GC
            fullGC();
            obj = oldGen.allocate(clazz);
            if (obj != null) return obj;
            
            // 5. 内存不足，抛出OOM
            throw new OutOfMemoryError("Java heap space");
        }
    }
    
    // 5. 方法区（Method Area）与元空间
    public class MethodArea {
        // JDK7之前：永久代（PermGen）
        // JDK8+：元空间（Metaspace）
        
        private final ClassLoaderData classLoaderData;
        private final RuntimeConstantPool constantPool;
        
        // 存储内容：类信息、常量、静态变量、即时编译器代码
        public void loadClass(String className) {
            // 类加载过程在方法区记录元数据
            ClassMetadata metadata = new ClassMetadata(className);
            // 存储到元空间
            storeClassMetadata(metadata);
        }
    }
}

第二章：堆内存结构与分代收集机制

2.1 堆内存分代模型

堆内存分代配置与对象分配：

/**
 * 堆内存分代模型详解
 */
public class HeapGenerationModel {
    
    // 堆内存分代比例配置
    public class GenerationConfiguration {
        // 年轻代占比（-XX:NewRatio）
        private double newRatio = 2.0; // 年轻代:老年代 = 1:2
        
        // Eden与Survivor比例（-XX:SurvivorRatio）
        private int survivorRatio = 8; // Eden:Survivor = 8:1:1
        
        // 对象晋升年龄阈值（-XX:MaxTenuringThreshold）
        private int maxTenuringThreshold = 15;
        
        // 大对象直接进入老年代阈值
        private int pretenureSizeThreshold = 1024 * 1024; // 1MB
    }
    
    // 对象分配流程模拟
    public class ObjectAllocator {
        private final YoungAllocator youngAllocator;
        private final OldAllocator oldAllocator;
        private int objectAge = 0;
        
        public Object allocate(Class<?> clazz, int size) {
            // 1. 检查是否为大对象
            if (size > pretenureSizeThreshold) {
                return oldAllocator.allocate(clazz, size);
            }
            
            // 2. 尝试在Eden区分配
            Object obj = youngAllocator.allocateEden(clazz, size);
            if (obj != null) {
                return obj;
            }
            
            // 3. Eden区不足，触发Minor GC
            minorGC();
            
            // 4. 重新尝试分配
            obj = youngAllocator.allocateEden(clazz, size);
            if (obj != null) {
                return obj;
            }
            
            // 5. 尝试老年代分配
            return oldAllocator.allocate(clazz, size);
        }
        
        // 对象年龄增长模拟
        public void incrementAge(Object obj) {
            objectAge++;
            if (objectAge >= maxTenuringThreshold) {
                promoteToOldGeneration(obj); // 晋升老年代
            }
        }
    }
    
    // GC日志分析示例
    public class GCLogAnalyzer {
        // 典型的GC日志模式
        public void analyzeGCLog(String logLine) {
            // [GC (Allocation Failure) [PSYoungGen: 8192K->1024K(9216K)] 
            //  8192K->2048K(19456K), 0.0023456 secs]
            
            // 解析关键信息：
            // - GC原因：Allocation Failure（分配失败）
            // - 年轻代：回收前8M->回收后1M（总9M）
            // - 堆内存：回收前8M->回收后2M（总19M）
            // - 耗时：2.3毫秒
        }
        
        // 内存溢出分析
        public void analyzeOOM(OutOfMemoryError error) {
            // Java heap space - 堆内存不足
            // PermGen space - 永久代不足（JDK7）
            // Metaspace - 元空间不足（JDK8+）
            // Unable to create new native thread - 栈内存不足
        }
    }
}

2.2 垃圾收集算法与实现

/**
 * 垃圾收集算法深度解析
 */
public class GarbageCollectionAlgorithms {
    
    // 1. 标记-清除算法（Mark-Sweep）
    public class MarkSweepGC {
        public void garbageCollect() {
            // 第一阶段：标记存活对象
            markLiveObjects();
            
            // 第二阶段：清除未标记对象
            sweepDeadObjects();
        }
        
        private void markLiveObjects() {
            // 从GC Roots开始遍历标记
            // 包括：虚拟机栈、本地方法栈、静态变量、常量等
        }
        
        private void sweepDeadObjects() {
            // 清理未标记的对象内存
            // 问题：产生内存碎片
        }
    }
    
    // 2. 复制算法（Copying）- 年轻代使用
    public class CopyingGC {
        private MemoryRegion fromSpace; // From Survivor
        private MemoryRegion toSpace;   // To Survivor
        
        public void minorGC() {
            // 将Eden和From Survivor的存活对象复制到To Survivor
            copyLiveObjects(fromSpace, toSpace);
            
            // 交换From和To角色
            swapSpaces();
        }
    }
    
    // 3. 标记-整理算法（Mark-Compact）- 老年代使用
    public class MarkCompactGC {
        public void fullGC() {
            markLiveObjects();     // 标记存活对象
            calculateNewAddresses(); // 计算新地址
            compactMemory();       // 整理内存
            updateReferences();    // 更新引用
        }
    }
    
    // 4. 分代收集策略
    public class GenerationalGC {
        private final double minorGCTime = 0.1;  // 年轻代GC时间
        private final double fullGCTime = 1.0;   // Full GC时间
        
        public void collect() {
            // 年轻代：复制算法，频率高，速度快
            if (youngGen.isFull()) {
                long start = System.currentTimeMillis();
                youngGen.minorGC();
                minorGCTime = System.currentTimeMillis() - start;
            }
            
            // 老年代：标记-整理，频率低，速度慢
            if (oldGen.isFull()) {
                long start = System.currentTimeMillis();
                oldGen.fullGC();
                fullGCTime = System.currentTimeMillis() - start;
            }
        }
    }
}

第三章：虚拟机栈与栈帧详细解析

3.1 栈帧结构与执行引擎

栈帧详细实现与操作：

/**
 * 虚拟机栈与栈帧实现详解
 */
public class JVMStackImplementation {
    
    // 栈帧完整结构
    public class StackFrame {
        private final Method method;           // 当前执行方法
        private final Class<?> declaringClass; // 方法所属类
        
        // 1. 局部变量表（Local Variable Table）
        private final Object[] localVariables;
        private final int maxLocals;
        
        // 2. 操作数栈（Operand Stack）
        private final Stack<Object> operandStack;
        private final int maxStack;
        
        // 3. 动态链接（Dynamic Linking）
        private final ConstantPool constantPool; // 运行时常量池引用
        private int pc; // 程序计数器（当前方法内）
        
        // 4. 方法返回信息
        private StackFrame callerFrame;    // 调用者栈帧
        private int returnPc;              // 返回地址
        
        public StackFrame(Method method, Object[] args) {
            this.method = method;
            this.maxLocals = method.getMaxLocals();
            this.maxStack = method.getMaxStack();
            this.localVariables = new Object[maxLocals];
            this.operandStack = new Stack<>();
            
            // 初始化局部变量表（参数存入）
            System.arraycopy(args, 0, localVariables, 0, args.length);
        }
        
        // 字节码执行模拟
        public void executeBytecode() {
            while (pc < method.getCodeLength()) {
                int opcode = method.getBytecode(pc);
                switch (opcode) {
                    case Opcodes.ILOAD:  // 加载int到操作数栈
                        int index = method.getBytecode(pc + 1);
                        operandStack.push(localVariables[index]);
                        pc += 2;
                        break;
                        
                    case Opcodes.IADD:   // 整数加法
                        int value2 = (Integer) operandStack.pop();
                        int value1 = (Integer) operandStack.pop();
                        operandStack.push(value1 + value2);
                        pc += 1;
                        break;
                        
                    case Opcodes.IRETURN: // 方法返回
                        returnToCaller();
                        break;
                }
            }
        }
    }
    
    // 方法调用深度监控
    public class StackDepthMonitor {
        private static final int MAX_STACK_DEPTH = 1024;
        private int currentDepth = 0;
        
        public void methodEnter(Method method) {
            currentDepth++;
            if (currentDepth > MAX_STACK_DEPTH) {
                throw new StackOverflowError("Method call too deep: " + currentDepth);
            }
            
            // 记录方法调用栈
            logStackTrace(method);
        }
        
        public void methodExit() {
            currentDepth--;
        }
        
        // 栈内存监控
        public void monitorStackUsage() {
            Thread thread = Thread.currentThread();
            int stackSize = thread.getStackTrace().length;
            long freeMemory = Runtime.getRuntime().freeMemory();
            
            if (stackSize > MAX_STACK_DEPTH * 0.8) {
                // 栈深度预警
                System.out.println("Stack depth warning: " + stackSize);
            }
        }
    }
}

第四章：方法区、永久代与元空间演进

4.1 从永久代到元空间的架构变革

元空间内部机制详解：

/**
 * 元空间架构与内存管理
 */
public class MetaspaceArchitecture {
    
    // 元空间核心组件
    public class MetaspaceStructure {
        // 1. 类加载器数据区（ClassLoaderData）
        private final Map<ClassLoader, ClassLoaderData> loaderDataMap;
        
        // 2. 元数据分配器
        private final MetadataAllocator allocator;
        
        // 3. 压缩类指针空间
        private final CompressedClassSpace compressedClassSpace;
        
        // 元空间统计信息
        public class MetaspaceStats {
            private long usedMetaspace;      // 已使用元空间
            private long capacityMetaspace;  // 元空间容量
            private long committedMetaspace; // 提交内存大小
            private long maxMetaspace;       // 最大元空间
        }
    }
    
    // 类元数据生命周期管理
    public class ClassMetadataLifecycle {
        
        // 类加载阶段
        public Class<?> loadClass(String name, byte[] bytecode) {
            // 1. 元空间分配内存存储类元数据
            ClassMetadata metadata = allocateClassMetadata(name);
            
            // 2. 解析常量池、方法、字段等元数据
            parseConstantPool(metadata, bytecode);
            parseMethods(metadata, bytecode);
            parseFields(metadata, bytecode);
            
            // 3. 链接和初始化
            linkClass(metadata);
            initializeClass(metadata);
            
            return metadata.getJavaClass();
        }
        
        // 类卸载条件
        public boolean canUnloadClass(Class<?> clazz) {
            // 1. 类的所有实例都被回收
            if (hasActiveInstances(clazz)) return false;
            
            // 2. 类的ClassLoader被回收
            if (clazz.getClassLoader() != null && 
                isClassLoaderAlive(clazz.getClassLoader())) return false;
            
            // 3. 类对应的java.lang.Class对象没有被引用
            if (isClassObjectReferenced(clazz)) return false;
            
            return true;
        }
    }
    
    // 元空间监控与调优
    public class MetaspaceMonitor {
        private final MBeanServer mbeanServer;
        private final ObjectName metaspaceMBean;
        
        public void monitorMetaspace() {
            // 获取元空间使用情况
            long used = (Long) mbeanServer.getAttribute(metaspaceMBean, "Used");
            long capacity = (Long) mbeanServer.getAttribute(metaspaceMBean, "Capacity");
            long committed = (Long) mbeanServer.getAttribute(metaspaceMBean, "Committed");
            
            double usageRatio = (double) used / capacity;
            
            if (usageRatio > 0.8) {
                // 元空间使用率过高预警
                System.out.println("Metaspace usage high: " + usageRatio);
            }
        }
        
        // 元空间GC触发条件
        public void checkMetaspaceGC() {
            // 当元空间使用达到阈值时触发GC
            if (needMetaspaceGC()) {
                System.gc(); // 触发Full GC回收元空间
            }
        }
    }
}

第五章：直接内存与堆外内存管理

5.1 直接内存机制与使用场景

/**
 * 直接内存（堆外内存）深度解析
 */
public class DirectMemoryManagement {
    
    // 直接内存分配器
    public class DirectByteBufferAllocator {
        private static final Unsafe unsafe = getUnsafe();
        private long allocatedMemory = 0;
        private final long maxDirectMemory;
        
        // 分配直接内存
        public ByteBuffer allocateDirect(int capacity) {
            // 检查内存限制
            if (allocatedMemory + capacity > maxDirectMemory) {
                // 尝试GC回收已清理的直接内存
                System.gc();
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                
                if (allocatedMemory + capacity > maxDirectMemory) {
                    throw new OutOfMemoryError("Direct buffer memory");
                }
            }
            
            // 使用Unsafe分配本地内存
            long address = unsafe.allocateMemory(capacity);
            allocatedMemory += capacity;
            
            // 创建Cleaner用于内存释放
            Cleaner cleaner = Cleaner.create(this, 
                new Deallocator(address, capacity));
                
            return new DirectByteBuffer(address, capacity, cleaner);
        }
        
        // 内存释放器
        private static class Deallocator implements Runnable {
            private final long address;
            private final long size;
            
            Deallocator(long address, long size) {
                this.address = address;
                this.size = size;
            }
            
            @Override
            public void run() {
                unsafe.freeMemory(address);
                allocatedMemory -= size;
            }
        }
    }
    
    // 直接内存使用场景
    public class DirectMemoryUsage {
        
        // 场景1：大文件内存映射
        public void memoryMappedFile() throws IOException {
            RandomAccessFile file = new RandomAccessFile("largefile.dat", "rw");
            FileChannel channel = file.getChannel();
            
            // 创建内存映射缓冲区
            MappedByteBuffer buffer = channel.map(
                FileChannel.MapMode.READ_WRITE, 0, channel.size());
            
            // 直接操作文件内容，避免内核态到用户态拷贝
            while (buffer.hasRemaining()) {
                byte b = buffer.get();
                processByte(b);
            }
            
            // 强制刷盘
            buffer.force();
        }
        
        // 场景2：网络IO高性能缓冲区
        public void networkIOBuffer() {
            // 分配直接内存作为网络缓冲区
            ByteBuffer buffer = ByteBuffer.allocateDirect(64 * 1024); // 64KB
            
            // 在NIO通道中使用
            SocketChannel channel = SocketChannel.open();
            channel.read(buffer);  // 零拷贝读取
            buffer.flip();
            channel.write(buffer); // 零拷贝写入
        }
        
        // 场景3：原生内存操作
        public void nativeMemoryOperation() {
            ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
            
            // 获取直接内存地址
            long address = ((DirectBuffer) buffer).address();
            
            // 使用Unsafe直接操作内存
            unsafe.putInt(address, 123);     // 写入int
            int value = unsafe.getInt(address); // 读取int
        }
    }
    
    // 直接内存监控工具
    public class DirectMemoryMonitor {
        public void monitorDirectMemory() {
            try {
                // 通过BufferPoolMXBean监控
                List<BufferPoolMXBean> pools = 
                    ManagementFactory.getPlatformMXBeans(BufferPoolMXBean.class);
                
                for (BufferPoolMXBean pool : pools) {
                    if ("direct".equals(pool.getName())) {
                        System.out.println("Direct Buffer Count: " + pool.getCount());
                        System.out.println("Direct Memory Used: " + pool.getMemoryUsed());
                        System.out.println("Direct Memory Total: " + pool.getTotalCapacity());
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

第六章：内存监控、调优与故障诊断

6.1 JVM内存监控工具链

/**
 * JVM内存监控与诊断工具
 */
public class JVMMemoryMonitoring {
    
    // 1. 命令行监控工具
    public class CommandLineTools {
        
        // jstat - 运行时监控
        public void jstatMonitoring() {
            // jstat -gc <pid> 1000 10
            // 每1秒采集一次GC情况，共10次
            
            // 输出指标：
            // S0C/S1C: Survivor区容量
            // S0U/S1U: Survivor区使用量
            // EC/EU: Eden区容量/使用量
            // OC/OU: 老年代容量/使用量
            // MC/MU: 元空间容量/使用量
            // YGC/YGCT: 年轻代GC次数/时间
            // FGC/FGCT: Full GC次数/时间
            // GCT: 总GC时间
        }
        
        // jmap - 内存转储
        public void jmapHeapDump() {
            // jmap -heap <pid>        # 堆内存概要
            // jmap -histo <pid>        # 对象直方图
            // jmap -dump:format=b,file=heap.bin <pid> # 堆转储
        }
        
        // jstack - 线程栈分析
        public void jstackAnalysis() {
            // jstack <pid> > thread.dump
            // 分析线程状态、锁竞争、死锁等
        }
    }
    
    // 2. JMX监控接口
    public class JMXMemoryMonitor {
        private final MBeanServer mbeanServer;
        
        public void monitorMemoryUsage() {
            // 获取内存池MBean
            List<MemoryPoolMXBean> pools = 
                ManagementFactory.getMemoryPoolMXBeans();
            
            for (MemoryPoolMXBean pool : pools) {
                MemoryUsage usage = pool.getUsage();
                String poolName = pool.getName();
                
                System.out.println("Pool: " + poolName);
                System.out.println("  Used: " + usage.getUsed() / 1024 / 1024 + "MB");
                System.out.println("  Max: " + usage.getMax() / 1024 / 1024 + "MB");
                System.out.println("  Usage: " + 
                    (usage.getUsed() * 100 / usage.getMax()) + "%");
            }
        }
        
        // GC监控
        public void monitorGC() {
            List<GarbageCollectorMXBean> gcBeans = 
                ManagementFactory.getGarbageCollectorMXBeans();
            
            for (GarbageCollectorMXBean gc : gcBeans) {
                System.out.println("GC: " + gc.getName());
                System.out.println("  Count: " + gc.getCollectionCount());
                System.out.println("  Time: " + gc.getCollectionTime() + "ms");
            }
        }
    }
    
    // 3. 程序化内存监控
    public class ProgrammaticMonitor {
        private final ScheduledExecutorService scheduler = 
            Executors.newScheduledThreadPool(1);
        
        public void startMemoryMonitoring() {
            scheduler.scheduleAtFixedRate(() -> {
                try {
                    Runtime runtime = Runtime.getRuntime();
                    long total = runtime.totalMemory();
                    long free = runtime.freeMemory();
                    long used = total - free;
                    long max = runtime.maxMemory();
                    
                    System.out.printf("Memory Usage: Used=%dMB, Free=%dMB, Total=%dMB, Max=%dMB%n",
                        used / 1024 / 1024, free / 1024 / 1024, 
                        total / 1024 / 1024, max / 1024 / 1024);
                    
                    // 监控堆外内存
                    monitorDirectMemory();
                    
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, 0, 5, TimeUnit.SECONDS); // 每5秒监控一次
        }
    }
}

6.2 内存泄漏诊断与优化

/**
 * 内存泄漏检测与优化实践
 */
public class MemoryLeakDetection {
    
    // 1. 内存泄漏模式识别
    public class MemoryLeakPatterns {
        
        // 模式1：静态集合引起的内存泄漏
        public class StaticCollectionLeak {
            private static final Map<String, Object> CACHE = new HashMap<>();
            
            public void addToCache(String key, Object value) {
                CACHE.put(key, value); // 对象永远无法被GC
            }
        }
        
        // 模式2：监听器未注销
        public class ListenerLeak {
            private final List<EventListener> listeners = new ArrayList<>();
            
            public void addListener(EventListener listener) {
                listeners.add(listener);
                // 忘记移除：removeListener方法缺失
            }
        }
        
        // 模式3：内部类持有外部类引用
        public class InnerClassLeak {
            private byte[] largeData = new byte[10 * 1024 * 1024]; // 10MB
            
            public Runnable createTask() {
                return new Runnable() { // 匿名内部类隐式持有外部类引用
                    @Override
                    public void run() {
                        System.out.println("Processing: " + largeData.length);
                    }
                };
            }
        }
    }
    
    // 2. 内存分析工具使用
    public class HeapDumpAnalysis {
        
        // 生成堆转储文件
        public void generateHeapDump() {
            try {
                // 使用JMX触发堆转储
                HotSpotDiagnosticMXBean diagnostic = 
                    ManagementFactory.getPlatformMXBean(HotSpotDiagnosticMXBean.class);
                diagnostic.dumpHeap("heapdump.hprof", true);
                
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        // 分析堆转储文件
        public void analyzeHeapDump() {
            // 使用Eclipse MAT或JProfiler分析：
            // 1. 查找大对象
            // 2. 分析对象引用链
            // 3. 识别内存泄漏点
            // 4. 查看GC Roots路径
        }
    }
    
    // 3. 内存优化最佳实践
    public class MemoryOptimization {
        
        // 优化1：使用软引用/弱引用缓存
        public class SoftReferenceCache<K, V> {
            private final Map<K, SoftReference<V>> cache = new HashMap<>();
            
            public void put(K key, V value) {
                cache.put(key, new SoftReference<>(value));
            }
            
            public V get(K key) {
                SoftReference<V> ref = cache.get(key);
                return ref != null ? ref.get() : null;
            }
        }
        
        // 优化2：对象池化
        public class ObjectPool<T> {
            private final Queue<SoftReference<T>> pool = new ConcurrentLinkedQueue<>();
            private final Supplier<T> factory;
            
            public T borrowObject() {
                SoftReference<T> ref;
                while ((ref = pool.poll()) != null) {
                    T obj = ref.get();
                    if (obj != null) return obj;
                }
                return factory.get();
            }
            
            public void returnObject(T obj) {
                pool.offer(new SoftReference<>(obj));
            }
        }
        
        // 优化3：及时释放资源
        public class ResourceCleanup {
            public void processWithCleanup() {
                ByteBuffer buffer = null;
                try {
                    buffer = ByteBuffer.allocateDirect(1024);
                    // 使用buffer...
                    
                } finally {
                    if (buffer != null) {
                        // 显式清理直接内存
                        if (buffer.isDirect()) {
                            Cleaner cleaner = ((DirectBuffer) buffer).cleaner();
                            if (cleaner != null) {
                                cleaner.clean();
                            }
                        }
                    }
                }
            }
        }
    }
}