Deep understanding of JVM (III) - memory structure (III)

In depth understanding of JVM（ 3、 ... and ）—— Memory structure （ 3、 ... and ）

6、 Direct memory

• Belongs to the operating system , Common in NIO In operation , For data buffers
• Higher allocated recovery costs , But the read-write performance is high
• Not subject to JVM Memory recovery management

File reading and writing process

Used DirectBuffer

Direct memory is the operating system and Java Code An area that can be accessed , There is no need to copy code from system memory to Java Heap memory , So it improves efficiency

Release principle

Direct memory recycling is not through JVM Garbage collection to release , But through unsafe.freeMemory To manually release

adopt

// adopt ByteBuffer apply 1M Of direct memory 
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1M);

Apply for direct memory , but JVM It does not reclaim the contents of direct memory , How does it achieve recycling ？

allocateDirect The implementation of the

public static ByteBuffer allocateDirect(int capacity) {
    return new DirectByteBuffer(capacity);
}

DirectByteBuffer class

DirectByteBuffer(int cap) {   // package-private
   
    super(-1, 0, cap, cap);
    boolean pa = VM.isDirectMemoryPageAligned();
    int ps = Bits.pageSize();
    long size = Math.max(1L, (long)cap + (pa ? ps : 0));
    Bits.reserveMemory(size, cap);

    long base = 0;
    try {
        base = unsafe.allocateMemory(size); // Application memory 
    } catch (OutOfMemoryError x) {
        Bits.unreserveMemory(size, cap);
        throw x;
    }
    unsafe.setMemory(base, size, (byte) 0);
    if (pa && (base % ps != 0)) {
        // Round up to page boundary
        address = base + ps - (base & (ps - 1));
    } else {
        address = base;
    }
    cleaner = Cleaner.create(this, new Deallocator(base, size, cap)); // By virtual reference , To release direct memory ,this An actual object that is a virtual reference 
    att = null;
}

Here's a call to Cleaner Of create Method , And the background thread will also monitor the virtual referenced objects , If the actual object of the virtual reference （ Here is DirectByteBuffer） After being recycled , Will call Cleaner Of clean Method , To clear the memory occupied in direct memory

public void clean() {
       if (remove(this)) {
           try {
               this.thunk.run(); // call run Method 
           } catch (final Throwable var2) {
               AccessController.doPrivileged(new PrivilegedAction<Void>() {
                   public Void run() {
                       if (System.err != null) {
                           (new Error("Cleaner terminated abnormally", var2)).printStackTrace();
                       }

                       System.exit(1);
                       return null;
                   }
               });
           }

Of the corresponding object run Method

public void run() {
    if (address == 0) {
        // Paranoia
        return;
    }
    unsafe.freeMemory(address); // Free up memory occupied in direct memory 
    address = 0;
    Bits.unreserveMemory(size, capacity);
}

Summary of the recycling mechanism of direct memory

• Used Unsafe Class to complete the allocation and recycling of direct memory , Recycling requires active invocation freeMemory Method
• ByteBuffer The implementation of uses Cleaner（ Virtual reference ） To detect ByteBuffer. once ByteBuffer Be recycled , Then by ReferenceHandler To call Cleaner Of clean Method call freeMemory To free up memory