什么是堆外内存？如何使用堆外内存？

问题

什么是堆外内存？如何使用堆外内存？

答案

核心概念

堆外内存(Off-Heap Memory),也称为直接内存(Direct Memory),是指在Java堆之外、通过本地方法直接分配的内存区域。这部分内存不受JVM堆大小限制,也不受GC直接管理,但可以被Java程序访问。

堆外内存的特点

1. 内存位置对比

┌─────────────────────────────────────────┐
│          操作系统物理内存                 │
├─────────────────────────────────────────┤
│  ┌─────────────────────────┐            │
│  │    JVM进程内存           │            │
│  ├─────────────────────────┤            │
│  │  Java堆 (-Xmx)          │            │
│  │  - 受GC管理              │            │
│  │  - 有大小限制            │            │
│  ├─────────────────────────┤            │
│  │  堆外内存 (Direct Memory)│            │
│  │  - 不受GC直接管理         │            │
│  │  - 本地内存分配          │            │
│  └─────────────────────────┘            │
└─────────────────────────────────────────┘

2. 核心特性

优势:

减少GC压力: 不在堆中,不影响GC时间
零拷贝(Zero-Copy): 避免堆内存和内核缓冲区之间的数据拷贝
共享内存: 可以在进程间共享
更大空间: 不受-Xmx限制,可用系统所有可用内存

劣势:

手动管理: 需要显式释放,容易泄漏
分配慢: 比堆内存分配慢
调试困难: 内存泄漏不易发现

使用堆外内存的方式

1. NIO的DirectByteBuffer

标准方式:

import java.nio.ByteBuffer;

public class DirectBufferExample {
    public static void main(String[] args) {
        // 分配10MB堆外内存
        ByteBuffer directBuffer = ByteBuffer.allocateDirect(10 * 1024 * 1024);

        // 写入数据
        directBuffer.put((byte) 1);
        directBuffer.putInt(100);
        directBuffer.putLong(999L);

        // 读取数据
        directBuffer.flip();
        byte b = directBuffer.get();
        int i = directBuffer.getInt();
        long l = directBuffer.getLong();

        System.out.println("byte: " + b + ", int: " + i + ", long: " + l);

        // 注意: DirectByteBuffer由GC触发Cleaner回收,或显式调用
        // 在JDK 9+可以使用: ((DirectBuffer)directBuffer).cleaner().clean();
    }
}

对比堆内Buffer:

// 堆内Buffer: 数据在Java堆中
ByteBuffer heapBuffer = ByteBuffer.allocate(1024);  // 在堆上分配

// 堆外Buffer: 数据在堆外内存中
ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024);  // 在堆外分配

2. Unsafe直接分配

底层方式(不推荐生产使用):

import sun.misc.Unsafe;
import java.lang.reflect.Field;

public class UnsafeDirectMemory {
    public static void main(String[] args) throws Exception {
        // 获取Unsafe实例(JDK 9+需要添加--add-opens参数)
        Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
        unsafeField.setAccessible(true);
        Unsafe unsafe = (Unsafe) unsafeField.get(null);

        // 分配1MB堆外内存
        long address = unsafe.allocateMemory(1024 * 1024);

        try {
            // 写入数据
            unsafe.putByte(address, (byte) 100);
            unsafe.putInt(address + 1, 999);

            // 读取数据
            byte b = unsafe.getByte(address);
            int i = unsafe.getInt(address + 1);

            System.out.println("byte: " + b + ", int: " + i);

            // 重新分配(扩容)
            address = unsafe.reallocateMemory(address, 2 * 1024 * 1024);

        } finally {
            // 必须手动释放,否则内存泄漏
            unsafe.freeMemory(address);
        }
    }
}

3. JNA/JNI调用本地库

import com.sun.jna.Memory;
import com.sun.jna.Pointer;

public class JNADirectMemory {
    public static void main(String[] args) {
        // 使用JNA分配堆外内存
        Memory memory = new Memory(1024);

        // 写入数据
        memory.setByte(0, (byte) 123);
        memory.setInt(1, 456);

        // 读取数据
        byte b = memory.getByte(0);
        int i = memory.getInt(1);

        System.out.println("byte: " + b + ", int: " + i);

        // JNA会自动释放内存(通过Finalizer)
    }
}

典型应用场景

1. NIO网络通信

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;

public class NIOServerExample {
    public static void main(String[] args) throws IOException {
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.bind(new InetSocketAddress(8080));

        // 使用直接内存减少拷贝
        ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024);

        SocketChannel clientChannel = serverChannel.accept();

        // 数据流: 网络 → 内核缓冲区 → DirectBuffer
        // 避免了: 网络 → 内核缓冲区 → 堆内存 → 内核缓冲区 的多次拷贝
        int bytesRead = clientChannel.read(directBuffer);

        directBuffer.flip();
        clientChannel.write(directBuffer);

        clientChannel.close();
        serverChannel.close();
    }
}

2. Netty框架

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;

public class NettyDirectMemory {
    public static void main(String[] args) {
        // Netty默认使用堆外内存(DirectBuffer)
        ByteBuf directBuf = Unpooled.directBuffer(1024);

        // 写入数据
        directBuf.writeInt(100);
        directBuf.writeBytes("Hello Netty".getBytes());

        // 读取数据
        int value = directBuf.readInt();
        byte[] bytes = new byte[directBuf.readableBytes()];
        directBuf.readBytes(bytes);

        System.out.println("Value: " + value);
        System.out.println("Message: " + new String(bytes));

        // Netty使用引用计数管理内存
        directBuf.release();
    }
}

3. 文件映射(MappedByteBuffer)

import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

public class MappedFileExample {
    public static void main(String[] args) throws Exception {
        RandomAccessFile file = new RandomAccessFile("test.dat", "rw");
        FileChannel channel = file.getChannel();

        // 将文件映射到堆外内存(零拷贝)
        MappedByteBuffer mappedBuffer = channel.map(
            FileChannel.MapMode.READ_WRITE, 0, 1024 * 1024  // 映射1MB
        );

        // 直接操作映射内存,修改会同步到文件
        mappedBuffer.put(0, (byte) 100);
        mappedBuffer.putInt(1, 999);

        // 强制同步到磁盘
        mappedBuffer.force();

        channel.close();
        file.close();
    }
}

堆外内存管理

1. 配置参数

# 设置最大堆外内存(默认等于-Xmx)
-XX:MaxDirectMemorySize=1g

# 示例配置
java -Xmx2g -XX:MaxDirectMemorySize=1g -jar app.jar

2. 内存回收机制

// DirectByteBuffer的回收机制
ByteBuffer buffer = ByteBuffer.allocateDirect(1024);

// 内部实现:
// 1. DirectByteBuffer持有一个Cleaner对象(JDK 8)或Deallocator(JDK 9+)
// 2. 当DirectByteBuffer被GC时,Cleaner/Deallocator触发,调用Unsafe.freeMemory()
// 3. 但回收不及时,可能导致堆外内存泄漏

// JDK 9+显式释放
// ((DirectBuffer) buffer).cleaner().clean();

3. 监控堆外内存

import java.lang.management.BufferPoolMXBean;
import java.lang.management.ManagementFactory;
import java.util.List;

public class DirectMemoryMonitor {
    public static void main(String[] args) {
        List<BufferPoolMXBean> pools = ManagementFactory.getPlatformMXBeans(BufferPoolMXBean.class);

        for (BufferPoolMXBean pool : pools) {
            System.out.println("Pool: " + pool.getName());
            System.out.println("Count: " + pool.getCount());
            System.out.println("Memory Used: " + pool.getMemoryUsed() / 1024 / 1024 + " MB");
            System.out.println("Total Capacity: " + pool.getTotalCapacity() / 1024 / 1024 + " MB");
        }
    }
}

4. 使用JMX监控

# 通过jconsole或VisualVM查看
# MBean: java.nio.BufferPool
# - direct: 堆外内存使用情况
# - mapped: 文件映射内存使用情况

性能对比

import java.nio.ByteBuffer;

public class HeapVsDirectPerformance {
    public static void main(String[] args) {
        int size = 1024 * 1024;  // 1MB
        int iterations = 10000;

        // 测试堆内Buffer
        long heapStart = System.currentTimeMillis();
        for (int i = 0; i < iterations; i++) {
            ByteBuffer heapBuffer = ByteBuffer.allocate(size);
            heapBuffer.put((byte) 1);
        }
        long heapTime = System.currentTimeMillis() - heapStart;

        // 测试堆外Buffer
        long directStart = System.currentTimeMillis();
        for (int i = 0; i < iterations; i++) {
            ByteBuffer directBuffer = ByteBuffer.allocateDirect(size);
            directBuffer.put((byte) 1);
        }
        long directTime = System.currentTimeMillis() - directStart;

        System.out.println("Heap buffer time: " + heapTime + "ms");
        System.out.println("Direct buffer time: " + directTime + "ms");

        // 结果: 堆内分配更快,但IO操作时堆外更快(零拷贝)
    }
}

常见问题

1. 堆外内存泄漏

// 错误示例: 未释放导致泄漏
public void leak() {
    while (true) {
        ByteBuffer.allocateDirect(1024 * 1024);  // 持续分配,GC不及时
        // 最终抛出: OutOfMemoryError: Direct buffer memory
    }
}

// 正确做法: 主动触发GC或复用Buffer
ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024);
// 使用完毕后,确保引用被释放
buffer = null;
System.gc();  // 建议JVM进行GC(Cleaner机制会释放堆外内存)

2. OOM异常

# 异常信息
java.lang.OutOfMemoryError: Direct buffer memory

# 解决方案
1. 增大MaxDirectMemorySize
2. 检查是否有内存泄漏
3. 及时释放不用的DirectBuffer
4. 使用对象池复用Buffer

最佳实践

合理使用场景:
- 大量网络IO、文件IO → 使用堆外内存
- 频繁创建销毁的小对象 → 使用堆内存

对象池复用:

// 使用对象池避免频繁分配
private static final Queue<ByteBuffer> bufferPool = new ConcurrentLinkedQueue<>();

public static ByteBuffer acquire() {
    ByteBuffer buffer = bufferPool.poll();
    if (buffer == null) {
        buffer = ByteBuffer.allocateDirect(1024);
    }
    buffer.clear();
    return buffer;
}

public static void release(ByteBuffer buffer) {
    bufferPool.offer(buffer);
}

监控和限制:

# 设置合理的MaxDirectMemorySize
-XX:MaxDirectMemorySize=512m

及时释放:

// 使用try-finally确保释放
ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
try {
    // 使用buffer
} finally {
    // JDK 9+
    // ((DirectBuffer) buffer).cleaner().clean();
}

面试总结

定义: 堆外内存是在Java堆之外、通过本地方法分配的内存,不受GC直接管理。

使用方式:

ByteBuffer.allocateDirect() (推荐)
Unsafe.allocateMemory() (底层,不推荐)
JNA/JNI调用本地库

典型场景:

NIO网络通信(减少拷贝)
Netty框架(高性能网络库)
文件映射(MappedByteBuffer)
大数据处理(Flink、Spark等)

优势: 减少GC压力、零拷贝、更大空间劣势: 分配慢、需要手动管理、调试困难

关键参数: -XX:MaxDirectMemorySize