Netty Review - 直接内存的应用及源码分析

package com.artisan.directbuffer;

import java.nio.ByteBuffer;

/**
 * 直接内存与堆内存的区别
 * @author artisan
 */
public class DirectMemoryTest {

    public static void heapAccess() {
        long startTime = System.currentTimeMillis();
        //分配堆内存
        ByteBuffer buffer = ByteBuffer.allocate(1000);
        for (int i = 0; i < 100000; i++) {
            for (int j = 0; j < 200; j++) {
                buffer.putInt(j);
            }
            buffer.flip();

            for (int j = 0; j < 200; j++) {
                buffer.getInt();
            }
            buffer.clear();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("堆内存访问:" + (endTime - startTime) + "ms");
    }

    public static void directAccess() {
        long startTime = System.currentTimeMillis();
        //分配直接内存
        ByteBuffer buffer = ByteBuffer.allocateDirect(1000);
        for (int i = 0; i < 100000; i++) {
            for (int j = 0; j < 200; j++) {
                buffer.putInt(j);
            }
            buffer.flip();
            for (int j = 0; j < 200; j++) {
                buffer.getInt();
            }
            buffer.clear();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("直接内存访问:" + (endTime - startTime) + "ms");
    }

  
    public static void main(String args[]) {
        for (int i = 0; i < 5; i++) {
            heapAccess();
            directAccess();
        }
    }
}

package com.artisan.directbuffer;

import java.nio.ByteBuffer;

/**
 * 直接内存与堆内存的区别
 * @author artisan
 */
public class DirectMemoryTest {

    public static void heapAllocate() {
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            ByteBuffer.allocate(100);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("堆内存申请:" + (endTime - startTime) + "ms");
    }

    public static void directAllocate() {
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            ByteBuffer.allocateDirect(100);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("直接内存申请:" + (endTime - startTime) + "ms");
    }

    public static void main(String args[]) {
 
        for (int i = 0; i < 5; i++) {
            heapAllocate();
            directAllocate();
        }
    }
}

public static ByteBuffer allocateDirect(int capacity) {
    if (capacity < 0)
        throw new IllegalArgumentException();
    return new DirectByteBuffer(capacity);
}

DirectByteBuffer(int cap) { // 包私有

    super(-1, 0, cap, cap); // 调用父类构造函数，设置position和limit为0，capacity为cap

    // 判断是否需要在直接内存页对齐
    boolean pa = VM.isDirectMemoryPageAligned();
    // 获取操作系统页面大小
    int ps = Bits.pageSize();
    // 计算需要分配的内存大小，如果需要页对齐，则在容量上加上一个页面大小
    long size = Math.max(1L, (long)cap + (pa ? ps : 0));


//判断是否有足够的直接内存空间分配，可通过‐XX:MaxDirectMemorySize=<size>参数指定直接内存最大可分配空间，如果不指定默认为最大堆内存大小，

//在分配直接内存时如果发现空间不够会显示调用System.gc()触发一次full gc回收掉一部分无用的直接内存的引用对象，同时直接内存也会被释放掉. 如果释放完分配空间还是不够会抛出异常java.lang.OutOfMemoryError

// 预留直接内存，如果分配失败，抛出OutOfMemoryError
    Bits.reserveMemory(size, cap);

    long base = 0;
    try {
        // 分配内存，并返回分配的内存地址
        base = unsafe.allocateMemory(size);
    } catch (OutOfMemoryError x) {
        // 如果分配失败，释放预留的内存，并抛出异常
        Bits.unreserveMemory(size, cap);
        throw x;
    }
    // 初始化分配的内存为0
    unsafe.setMemory(base, size, (byte) 0);
    if (pa && (base % ps != 0)) {
        // 如果需要页对齐，并且分配的内存地址不在页面边界上，将地址向上舍入到页面边界
        address = base + ps - (base & (ps - 1));
    } else {
        address = base;
    }
    // 创建Cleaner对象，用于释放内存
    // 使用Cleaner机制注册内存回收处理函数，当直接内存引用对象被GC清理掉时，会提前调用这里注册的释放直接内存的Deallocator线程对象的run方法
    cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
    att = null;
}

UNSAFE_ENTRY(jlong, Unsafe_AllocateMemory(JNIEnv *env, jobject unsafe, jlong size))
    // 使用UnsafeWrapper宏定义的函数进行包装
    UnsafeWrapper("Unsafe_AllocateMemory");

    // 将传入的jlong类型的size转换为size_t类型的sz，这是为了在C++中使用
    size_t sz = (size_t)size;

    // 检查size是否为负数或超出了jlong类型的范围，如果是，则抛出IllegalArgumentException异常
    if (sz != (julong)size || size < 0) {
        THROW_0(vmSymbols::java_lang_IllegalArgumentException());
    }

    // 如果size为0，则直接返回0，不进行内存分配
    if (sz == 0) {
        return 0;
    }

    // 将sz向上舍入到HeapWordSize的倍数，确保内存对齐
    sz = round_to(sz, HeapWordSize);

    // 调用os::malloc函数分配内存。os::malloc是JVM调用操作系统的内存分配函数，通常是malloc
    void* x = os::malloc(sz, mtInternal);

    // 如果内存分配失败（返回NULL），则抛出OutOfMemoryError异常
    if (x == NULL) {
        THROW_0(vmSymbols::java_lang_OutOfMemoryError());
    }

    // 将分配的内存地址转换为Java对象引用并返回
    return addr_to_java(x);
UNSAFE_END

package com.artisan.directbuffer;

import java.nio.ByteBuffer;

/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 */
public class DirectMemoryManager {


    private ByteBuffer buffer;

    public DirectMemoryManager(int capacity) {
        // 申请直接内存
        buffer = ByteBuffer.allocateDirect(capacity);
    }

    // 使用直接内存进行读写操作
    public void writeToBuffer(byte[] data) {
        buffer.put(data);
    }

    
    public byte[] readFromBuffer() {
        // 将缓冲区的位置设为 0，限制设为当前位置
        buffer.flip();
        byte[] data = new byte[buffer.remaining()];
        buffer.get(data);
        return data;
    }

    // 释放直接内存
    public void releaseMemory() {
        // 释放 buffer 对象
        buffer.clear();
        // 将 buffer 设置为 null，便于垃圾回收
        buffer = null;
        // 强制调用垃圾回收器进行内存回收
        System.gc();
    }

    public static void main(String[] args) {
        // 创建直接内存管理器并分配直接内存
        DirectMemoryManager memoryManager = new DirectMemoryManager(1024);

        // 使用直接内存进行读写操作
        byte[] data = "Hello, Direct Memory!".getBytes();
        memoryManager.writeToBuffer(data);
        byte[] readData = memoryManager.readFromBuffer();
        System.out.println("Read from buffer: " + new String(readData));

        // 释放直接内存
        memoryManager.releaseMemory();
    }
}