Java 低延迟编程：堆外内存（ByteBuffer）与Unsafe类

// 传统堆内存分配的问题
public class HeapAllocation {public void process() {byte[] buffer = new byte[1024]; // 在堆上分配// 使用buffer...}
}

// 分配1MB直接内存缓冲区
ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024 * 1024);// 基本操作
directBuffer.putInt(0, 123);  // 绝对位置写入
directBuffer.position(4);     // 移动位置指针
directBuffer.putDouble(3.14); // 相对位置写入
directBuffer.flip();          // 准备读取
int value = directBuffer.getInt();

// 重要ByteBuffer属性
System.out.println("是否为直接缓冲区: " + directBuffer.isDirect());
System.out.println("字节顺序: " + directBuffer.order()); // 默认BIG_ENDIAN
System.out.println("内存对齐: " + Unsafe.ARRAY_BYTE_BASE_OFFSET);

// 反射获取Unsafe实例
Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
theUnsafe.setAccessible(true);
Unsafe unsafe = (Unsafe) theUnsafe.get(null);

// 分配100字节堆外内存
long address = unsafe.allocateMemory(100);try {// 内存操作unsafe.putInt(address, 42);unsafe.putDouble(address + 4, 3.14159);// 读取验证System.out.println(unsafe.getInt(address));System.out.println(unsafe.getDouble(address + 4)));
} finally {unsafe.freeMemory(address); // 必须手动释放
}

// 确保8字节对齐访问
long alignedAddress = (address + 7) & ~7;
unsafe.putLong(alignedAddress, 0x123456789ABCDEF0L);

// 使用Unsafe绕过数组边界检查
byte[] array = new byte[100];
long baseOffset = unsafe.arrayBaseOffset(byte[].class);
unsafe.putByte(array, baseOffset + 50, (byte)1); // 不检查边界

// 原子计数器实现
public class AtomicCounter {private volatile long value;private static final long VALUE_OFFSET;static {try {VALUE_OFFSET = unsafe.objectFieldOffset(AtomicCounter.class.getDeclaredField("value"));} catch (Exception e) { throw new Error(e); }}public long increment() {long v;do {v = unsafe.getLongVolatile(this, VALUE_OFFSET);} while (!unsafe.compareAndSwapLong(this, VALUE_OFFSET, v, v + 1));return v + 1;}
}

// 使用直接缓冲区解析行情数据
public class MarketDataParser {private final ByteBuffer buffer;public MarketDataParser(ByteBuffer buffer) {this.buffer = buffer;this.buffer.order(ByteOrder.LITTLE_ENDIAN); // 交易所常用小端序}public double getPrice(int offset) {return buffer.getDouble(offset + 16); // 价格字段偏移量}public long getVolume(int offset) {return buffer.getLong(offset + 24);   // 成交量字段偏移量}
}

// 使用FileChannel实现零拷贝
try (FileChannel channel = FileChannel.open(Paths.get("data.bin"), StandardOpenOption.READ)) {ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024);while (channel.read(buffer) != -1) {buffer.flip();// 处理数据...buffer.clear();}
}

// 简单的直接内存池实现
public class DirectMemoryPool {private final List<ByteBuffer> pool = new ArrayList<>();public ByteBuffer acquire(int size) {// 查找可用缓冲区...return ByteBuffer.allocateDirect(size);}public void release(ByteBuffer buffer) {buffer.clear();pool.add(buffer);}
}

// 资源清理模板
public class DirectMemoryResource implements AutoCloseable {private final long address;private final long size;public DirectMemoryResource(long size) {this.address = unsafe.allocateMemory(size);this.size = size;}@Overridepublic void close() {unsafe.freeMemory(address);}
}// 使用try-with-resources确保释放
try (DirectMemoryResource res = new DirectMemoryResource(1024)) {// 使用堆外内存...
}

@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class MemoryAccessBenchmark {private byte[] heapArray;private ByteBuffer directBuffer;private long unsafeAddress;@Setuppublic void setup() {heapArray = new byte[1024];directBuffer = ByteBuffer.allocateDirect(1024);unsafeAddress = unsafe.allocateMemory(1024);}// 测试方法...
}

// 错误的指针操作导致JVM崩溃
long invalidAddress = 0x1234;
unsafe.putInt(invalidAddress, 42); // 可能导致SIGSEGV

// 使用Java 9+的VarHandle
public class SafeCounter {private volatile long value;private static final VarHandle VALUE_HANDLE;static {try {VALUE_HANDLE = MethodHandles.lookup().findVarHandle(SafeCounter.class, "value", long.class);} catch (Exception e) { throw new Error(e); }}public long increment() {long v;do {v = (long) VALUE_HANDLE.get(this);} while (!VALUE_HANDLE.compareAndSet(this, v, v + 1));return v + 1;}
}

// 更安全的外部内存访问
try (MemorySegment segment = MemorySegment.allocateNative(100)) {VarHandle intHandle = MemoryHandles.varHandle(int.class, ByteOrder.nativeOrder());intHandle.set(segment.baseAddress(), 42);System.out.println(intHandle.get(segment.baseAddress()));
}

// 未来可能的API（预览）
MemoryAddress address = MemoryAllocator.getDefault().allocate(1024);
MemoryAccess.setInt(address, 0x12345678);

// 使用Direct ByteBuffer
ByteBuffer buffer = ByteBuffer.allocateDirect(size);

// 谨慎使用Unsafe
long address = unsafe.allocateMemory(size);
try {// 关键路径操作...
} finally {unsafe.freeMemory(address);
}

// 使用Foreign-Memory API
MemorySegment segment = MemorySegment.allocateNative(size);