【Java】 DirectByteBuffer堆外記憶體回收-有解無憂

PhantomReference虛參考

在分析堆外記憶體回收之前，先了解下PhantomReference虛參考，

PhantomReference需要與ReferenceQueue參考佇列結合使用，在GC進行垃圾回收的時候，如果發現一個物件只有虛參考在參考它，則認為該物件需要被回收，會將參考該物件的虛參考加入到與其關聯的ReferenceQueue佇列中，開發者可以通過ReferenceQueue獲取需要被回收的物件，然后做一些清理操作，從佇列中獲取過的元素會從佇列中清除，之后GC就可以對該物件進行回收，

虛參考提供了一種追蹤物件垃圾回收狀態的機制，讓開發者知道哪些物件準備進行回收，在回收之前開發者可以進行一些清理作業，之后GC就可以將物件進行真正的回收，

來看一個虛參考的使用例子：

創建一個ReferenceQueue佇列queue，用于跟蹤物件的回收；
創建一個obj物件，通過new創建的是強參考，只要強參考存在，物件就不會被回收；
創建一個虛參考PhantomReference，將obj物件和ReferenceQueue佇列傳入，此時phantomReference里面參考了obj物件，并關聯著參考佇列queue；
同樣的方式創建另一個obj1物件和虛參考物件phantomReference1；
將obj置為NULL，此時強參考關系失效；
呼叫 System.gc()進行垃圾回收；
由于obj的強參考關系失效，所以GC認為該物件需要被回收，會將參考該物件的虛參考phantomReference物件放入到與其關聯的參考佇列queue中；
通過poll從參考佇列queue中獲取物件，可以發現會獲取到phantomReference物件，poll獲取之后會將物件從參考佇列中洗掉，之后會被垃圾回收器回收；
obj1的強參考關系還在，所以從queue中并不會獲取到；

   public static void main(String[] args) {
        // 創建參考佇列
        ReferenceQueue<Object> queue = new ReferenceQueue<Object>();
        // 創建obj物件
        Object obj = new Object();
        // 創建虛參考，虛參考參考了obj物件，并與queue進行關聯
        PhantomReference<Object> phantomReference = new PhantomReference<Object>(obj, queue);
        // 創建obj1物件
        Object obj1 = new Object();
        PhantomReference<Object> phantomReference1 = new PhantomReference<Object>(obj1, queue);
        // 將obj置為NULL，強參考關系失效
        obj = null;
        // 垃圾回收
        System.gc();
        // 從參考佇列獲取物件
        Object o = queue.poll();
        if (null != o) {
            System.out.println(o.toString());
        }
    }

輸出結果：

java.lang.ref.PhantomReference@277c0f21

Reference實體的幾種狀態

Active：初始狀態，創建一個Reference型別的實體之后處于Active狀態，以上面虛參考為例，通過new創建一個PhantomReference虛參考物件之后，虛參考物件就處于Active狀態，

Pending：當GC檢測到物件的可達性發生變化時，會根據是否關聯了參考佇列來決定是否將狀態更改為Pending或者Inactive，虛參考必須與參考佇列結合使用，所以對于虛參考來說，如果它實際參考的物件需要被回收，垃圾回收器會將這個虛參考物件加入到一個Pending串列中，此時處于Pending狀態，

同樣以上面的的虛參考為例，因為obj的強參考關系失效，GC就會把參考它的虛參考物件放入到pending串列中，

Enqueued：表示參考物件被加入到了參考佇列，Reference有一個后臺執行緒去檢測是否有處于Pending狀態的參考物件，如果有會將參考物件加入到與其關聯的參考佇列中，此時由Pending轉為Enqueued狀態表示物件已加入到參考佇列中，

Inactive：通過參考佇列的poll方法可以從參考佇列中獲取參考物件，同時參考物件會從佇列中移除，此時參考物件處于Inactive狀態，之后會被GC回收，

DirectByteBuffer堆外記憶體回收

在DirectByteBuffer的建構式中，在申請記憶體之前，先呼叫了Bits的reserveMemory方法回收記憶體，申請記憶體之后，呼叫Cleaner的create方法創建了一個Cleaner物件，并傳入了當前物件（DirectByteBuffer）和一個Deallocator型別的物件：

class DirectByteBuffer extends MappedByteBuffer implements DirectBuffer {
    private final Cleaner cleaner;
        
    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);
        } 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;
        }
        // 創建Cleader，傳入了當前物件和Deallocator
        cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
        att = null;
    }
}

Cleaner從名字上可以看出與清理有關，Bits的reserveMemory方法底層也是通過Cleaner來進行清理，所以Cleaner是重點關注的類，

Deallocator是DirectByteBuffer的一個內部類，并且實作了Runnable介面，在run方法中可以看到對記憶體進行了釋放，接下來就去看下在哪里觸發Deallocator任務的執行：

class DirectByteBuffer extends MappedByteBuffer implements DirectBuffer {

    private static class Deallocator implements Runnable {
        // ...
        
        private Deallocator(long address, long size, int capacity) {
            assert (address != 0);
            this.address = address; // 設定記憶體地址
            this.size = size;
            this.capacity = capacity;
        }

        public void run() {
            if (address == 0) {
                // Paranoia
                return;
            }
            // 釋放記憶體
            unsafe.freeMemory(address);
            address = 0;
            Bits.unreserveMemory(size, capacity);
        }

    }
}

Cleaner

Cleaner繼承了PhantomReference，PhantomReference是Reference的子類，所以Cleaner是一個虛參考物件，

創建Cleaner

虛參考需要與參考佇列結合使用，所以在Cleaner中可以看到有一個ReferenceQueue，它是一個靜態的變數，所以創建的所有Cleaner物件都會共同使用這個參考佇列，

在創建Cleaner的create方法中，處理邏輯如下：

通過建構式創建了一個Cleaner物件，建構式中的referent引數為DirectByteBuffer，thunk引數為Deallocator物件，在建構式中又呼叫了父類的建構式完成實體化；
呼叫add方法將創建的Cleaner物件加入到鏈表中，添加到鏈表的時候使用的是頭插法，新加入的節點放在鏈表的頭部，first成員變數是一個靜態變數，它指向鏈表的頭結點，創建的Cleaner都會加入到這個鏈表中；

創建后的Cleaner物件處于Active狀態，

 public class Cleaner extends PhantomReference<Object>{

    // ReferenceQueue佇列
    private static final ReferenceQueue<Object> dummyQueue = new ReferenceQueue<>();

    // 靜態變數，鏈表的頭結點，創建的Cleaner都會加入到這個鏈表中
    static private Cleaner first = null;
     
    // thunk
    private final Runnable thunk;
     
    public static Cleaner create(Object ob, Runnable thunk) {
        if (thunk == null)
            return null;
        // 創建一個Cleaner并加入鏈表
        return add(new Cleaner(ob, thunk));
    }
    
    private Cleaner(Object referent, Runnable thunk) {
        super(referent, dummyQueue); // 呼叫父類建構式，傳入參考物件和參考佇列
        this.thunk = thunk; // thunk指向傳入的Deallocator
    }
     
    private static synchronized Cleaner add(Cleaner cl) {
        // 如果頭結點不為空
        if (first != null) {
            // 將新加入的節點作為頭結點
            cl.next = first; 
            first.prev = cl;
        }
        first = cl;
        return cl;
    }
}

Cleaner呼叫父類建構式時，最侄訓進入到父類Reference中的建構式中：

referent：指向實際的參考物件，上面創建的是DirectByteBuffer，所以這里指向的是DirectByteBuffer，

queue：參考佇列，指向Cleaner中的參考佇列dummyQueue，

public class PhantomReference<T> extends Reference<T> {
    // ...
    
    public PhantomReference(T referent, ReferenceQueue<? super T> q) {
        super(referent, q); // 呼叫父類建構式
    }

}

public abstract class Reference<T> {
    /* 參考物件 */
    private T referent;         
    // 參考佇列
    volatile ReferenceQueue<? super T> queue;
    
    Reference(T referent, ReferenceQueue<? super T> queue) {
        this.referent = referent;
        // 設定參考佇列
        this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
    }

}

啟動ReferenceHandler執行緒

Reference中有一個靜態方法，里面創建了一個ReferenceHandler并設定為守護執行緒，然后啟動了該執行緒，并創建了JavaLangRefAccess物件設定到SharedSecrets中：

public abstract class Reference<T> {
    static {
        ThreadGroup tg = Thread.currentThread().getThreadGroup();
        for (ThreadGroup tgn = tg;
             tgn != null;
             tg = tgn, tgn = tg.getParent());
        // 創建ReferenceHandler
        Thread handler = new ReferenceHandler(tg, "Reference Handler");
        // 設定優先級為最高
        handler.setPriority(Thread.MAX_PRIORITY);
        handler.setDaemon(true);
        handler.start();

        // 這里設定了JavaLangRefAccess
        SharedSecrets.setJavaLangRefAccess(new JavaLangRefAccess() {
            @Override
            public boolean tryHandlePendingReference() {
                // 呼叫了tryHandlePending
                return tryHandlePending(false);
            }
        });
    }
}

ReferenceHandler是Reference的內部類，繼承了Thread，在run方法中開啟了一個回圈，不斷的執行tryHandlePending方法，處理Reference中的pending串列：

public abstract class Reference<T> {
    
    private static class ReferenceHandler extends Thread {
        
        // ...
        
        ReferenceHandler(ThreadGroup g, String name) {
            super(g, name);
        }

        public void run() {
            while (true) {
                // 處理pending串列
                tryHandlePending(true);
            }
        }
    }
 }

Cleaner會啟動一個優先級最高的守護執行緒，不斷呼叫tryHandlePending來檢測是否有需要回收的參考物件(還未進行真正的回收)，然后進行處理，

處理pending串列

垃圾回收器會將要回收的參考物件放在Reference的pending變數中，從資料型別上可以看出pending只是一個Reference型別的物件，并不是一個list，如果有多個需要回收的物件，如何將它們全部放入pending物件中？

可以把pengding看做是一個鏈表的頭結點，假如有參考物件被判定需要回收，如果pengding為空直接放入即可，如果不為空，將使用頭插法將新的物件加入到鏈表中，也就是將新物件的discovered指向pending物件，然后將pending指向當前要回收的這個物件，這樣就形成了一個鏈表，pending指向鏈表的頭結點，

在pending鏈表中的參考物件處于pending狀態，

接下來看tryHandlePending方法的處理邏輯：

如果pending不為空，表示有需要回收的物件，此時將pengding指向的物件放在臨時變數r中，并判斷是否是Cleaner型別，如果是將其強制轉為Cleaner，記錄在臨時變數c中，接著更新pending的值為r的discovered，因為discovered中記錄了下一個需要被回收的物件，pengding需要指向下一個需要被回收的物件；

pending如果為NULL，會進入到else的處理邏輯，回傳值為引數傳入的waitForNotify的值，
判斷Cleaner物件是否為空，如果不為空，呼叫Cleaner的clean方法進行清理；
獲取參考物件關聯的參考佇列，然后呼叫enqueue方法將參考物件加入到參考佇列中；
回傳true；

public abstract class Reference<T> {
  
    // 指向pending串列中的下一個節點
    transient private Reference<T> discovered; 

    // 靜態變數pending串列，可以看做是一個鏈表，pending指向鏈表的頭結點
    private static Reference<Object> pending = null;
  
    static boolean tryHandlePending(boolean waitForNotify) {
        Reference<Object> r;
        Cleaner c;
        try {
            synchronized (lock) {
                // 如果pending不為空
                if (pending != null) {
                    // 獲取pending執行的物件
                    r = pending;
                    // 如果是Cleaner型別
                    c = r instanceof Cleaner ? (Cleaner) r : null;
                    // 將pending指向下一個節點
                    pending = r.discovered;
                    // 將discovered置為空
                    r.discovered = null;
                } else {
                    // 等待
                    if (waitForNotify) {
                        lock.wait();
                    }
                    return waitForNotify;
                }
            }
        } catch (OutOfMemoryError x) {
            Thread.yield();
            // retry
            return true;
        } catch (InterruptedException x) {
            // retry
            return true;
        }
        if (c != null) {
            // 呼叫clean方法進行清理
            c.clean();
            return true;
        }
        // 獲取參考佇列
        ReferenceQueue<? super Object> q = r.queue;
        // 如果佇列不為空，將物件加入到參考佇列中
        if (q != ReferenceQueue.NULL) q.enqueue(r);
        // 回傳true
        return true;
    }
}

釋放記憶體

在Cleaner的clean方法中，可以看到，呼叫了thunk的run方法，前面內容可知，thunk指向的是Deallocator物件，所以會執行Deallocator的run方法，Deallocator的run方法前面也已經看過，里面會對DirectByteBuffer的堆外記憶體進行釋放：

public class Cleaner extends PhantomReference<Object> {

    public void clean() {
        if (!remove(this))
            return;
        try {
            // 呼叫run方法
            thunk.run();
        } catch (final Throwable x) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        if (System.err != null)
                            new Error("Cleaner terminated abnormally", x)
                                .printStackTrace();
                        System.exit(1);
                        return null;
                    }});
        }
    }
}

總結

Cleaner是一個虛參考，它實際參考的物件DirectByteBuffer如果被GC判定為需要回收，會將參考該物件的Cleaner加入到pending串列，ReferenceHandler執行緒會不斷檢測pending是否為空，如果不為空，就對其進行處理：

如果物件型別為Cleaner，就呼叫Cleaner的clean方法進行清理，Cleaner的clean方法又會呼叫Deallocator的run方法，里面呼叫了freeMemory方法對DirectByteBuffer分配的堆外記憶體進行釋放；
將Cleaner物件加入到與其關聯的參考佇列中；

參考佇列

ReferenceQueue名字聽起來是一個佇列，實際使用了一個鏈表，使用頭插法將加入的節點串起來，ReferenceQueue中的head變數指向鏈表的頭節點，每個節點是一個Reference型別的物件：

public class ReferenceQueue<T> {

    // head為鏈表頭節點
    private volatile Reference<? extends T> head = null;
}

Reference中除了discovered變數之外，還有一個next變數，discovered指向的是處于pending狀態時pending串列中的下一個元素，next變數指向的是處于Enqueued狀態時，參考佇列中的下一個元素：

public abstract class Reference<T> {

    /* When active:   處于active狀態時為NULL
     *     pending:   this
     *    Enqueued:   Enqueued狀態時，指向參考佇列中的下一個元素
     *    Inactive:   this
     */
    @SuppressWarnings("rawtypes")
    Reference next;
    
    /* When active:   active狀態時，指向GC維護的一個discovered鏈表中的下一個元素
     *     pending:   pending狀態時，指向pending串列中的下一個元素
     *   otherwise:   其他情況為NULL
     */
    transient private Reference<T> discovered;  /* used by VM */
}

enqueue入隊

進入參考佇列中的參考物件處于enqueue狀態，

enqueue的處理邏輯如下：

判斷要加入的物件關聯的參考佇列，對佇列進行判斷，如果佇列為慷訓者佇列等于ReferenceQueue中的空佇列ENQUEUED，表示該物件之前已經加入過佇列，不能重復操作，回傳false，如果未加入過繼續下一步；
將物件所關聯的參考佇列置為ENQUEUED，它是一個空佇列，表示節點已經加入到佇列中；
判斷頭節點是否為空，如果為空，表示鏈表還沒有節點，將當前物件的next指向自己，如果頭結點不為空，將當前物件的next指向頭結點，然后更新頭結點的值為當前物件（頭插法插入鏈表）；
增加佇列的長度，也就是鏈表的長度；

public class ReferenceQueue<T> {

    // 空佇列
    static ReferenceQueue<Object> ENQUEUED = new Null<>();
    
    // 入隊，將節點加入參考佇列，佇列實際上是一個鏈表
    boolean enqueue(Reference<? extends T> r) {
        synchronized (lock) {
            // 獲取關聯的參考佇列
            ReferenceQueue<?> queue = r.queue;
            // 如果為慷訓者已經添加到過佇列
            if ((queue == NULL) || (queue == ENQUEUED)) {
                return false;
            }
            assert queue == this;
            // 將參考佇列置為一個空佇列，表示該節點已經入隊
            r.queue = ENQUEUED;
            // 如果頭結點為空將下一個節點置為自己，否則將next置為鏈表的頭結點，可以看出同樣使用的是頭插法將節點插入鏈表
            r.next = (head == null) ? r : head;
            // 更新頭結點為當前節點
            head = r;
            // 增加長度
            queueLength++;
            if (r instanceof FinalReference) {
                sun.misc.VM.addFinalRefCount(1);
            }
            lock.notifyAll();
            return true;
        }
    }
}

poll出隊

在呼叫poll方法從參考佇列中獲取一個元素并出隊的時候，首先對head頭結點進行判空，如果為空表示參考佇列中沒有資料，回傳NULL，否則呼叫reallyPoll從參考佇列中獲取元素，

出隊的處理邏輯如下：

獲取鏈表中的第一個節點也就是頭結點，如果不為空進行下一步；
如果頭節點的下一個節點是自己，表示鏈表只有一個節點，頭結點出隊之后鏈表為空，所以將頭結點的值更新為NULL；

如果頭節點的下一個節點不是自己，表示鏈表中還有其他節點，更新head頭節點的值為下一個節點，也就是next指向的物件；
將需要出隊的節點的參考佇列置為NULL，next節點置為自己，表示節點已從佇列中洗掉；
參考佇列的長度減一；
回傳要出隊的節點；

從出隊的邏輯中可以看出，參考佇列中的物件是后進先出的，poll出隊之后的參考物件處于Inactive狀態，表示可以被GC回收掉，

public class ReferenceQueue<T> {
    /**
     * 從參考佇列中獲取一個節點，進行出隊操作
     */
    public Reference<? extends T> poll() {
        // 如果頭結點為空，表示沒有資料 
        if (head == null)
            return null;
        synchronized (lock) {
            return reallyPoll();
        }
    }
    
    @SuppressWarnings("unchecked")
    private Reference<? extends T> reallyPoll() {     、  /* Must hold lock */
        // 獲取頭結點
        Reference<? extends T> r = head;
        if (r != null) {
            // 如果頭結點的下一個節點是自己，表示鏈表只有一個節點，head置為null，否則head值為r的下一個節點，也就是next指向的物件
            head = (r.next == r) ?
                null :
                r.next;
            // 將參考佇列置為NULL
            r.queue = NULL;
            // 下一個節點置為自己
            r.next = r;
            // 長度減一
            queueLength--;
            if (r instanceof FinalReference) {
                sun.misc.VM.addFinalRefCount(-1);
            }
            // 回傳鏈表中的第一個節點
            return r;
        }
        return null;
    }
}

reserveMemory記憶體清理

最開始在DirectByteBuffer的建構式中看到申請記憶體之前會呼叫Bits的reserveMemory方法，如果沒有足夠的記憶體，它會從SharedSecrets獲取JavaLangRefAccess物件進行一些處理，由前面的內容可知，Reference中的靜態方法啟動ReferenceHandler之后，創建了JavaLangRefAccess并設定到SharedSecrets中，所以這里呼叫JavaLangRefAccess的tryHandlePendingReference實際上依舊呼叫的是Reference中的tryHandlePending方法，

在呼叫Reference中的tryHandlePending方法處理需要回收的物件之后，呼叫tryReserveMemory方法判斷是否有足夠的記憶體，如果記憶體依舊不夠，會呼叫` System.gc()觸發垃圾回收，然后開啟一個回圈，處理邏輯如下：

判斷記憶體是否充足，如果充足直接回傳；
判斷睡眠次數是否小于限定的最大值，如果小于繼續下一步，否則終止回圈；
呼叫tryHandlePendingReference處理penging串列中的參考物件，前面在處理pending串列的邏輯中可以知道，如果pending串列不為空，會回傳true，tryHandlePendingReference也會回傳true，此時意味著清理了一部分物件，所以重新進入到第1步進行檢查；

如果pending串列為空，會回傳引數中傳入的waitForNotify的值，從JavaLangRefAccess的tryHandlePendingReference中可以看出這里傳入的是false，所以會進行如下處理：
- 通過 Thread.sleep(sleepTime)讓當前執行緒睡眠一段時間，這樣可以避免reserveMemory方法一直在占用資源;
- 對睡眠次數加1;
如果以上步驟處理之后還沒有足夠的空間會拋出拋出OutOfMemoryError例外；

reserveMemory方法的作用是保證在申請記憶體之前有足夠的記憶體，如果沒有足夠的記憶體會進行清理，達到指定清理次數之后依舊沒有足夠的記憶體空間，將拋出OutOfMemoryError例外，

class Bits {

    static void reserveMemory(long size, int cap) {

        if (!memoryLimitSet && VM.isBooted()) {
            maxMemory = VM.maxDirectMemory();
            memoryLimitSet = true;
        }

        // 是否有足夠記憶體
        if (tryReserveMemory(size, cap)) {
            return;
        }
        // 獲取JavaLangRefAccess
        final JavaLangRefAccess jlra = SharedSecrets.getJavaLangRefAccess();
        // 呼叫tryHandlePendingReference
        while (jlra.tryHandlePendingReference()) {
            // 判斷是否有足夠的記憶體
            if (tryReserveMemory(size, cap)) {
                return;
            }
        }

        // 呼叫gc進行垃圾回收
        System.gc();

        boolean interrupted = false;
        try {
            long sleepTime = 1;
            int sleeps = 0;
            // 開啟回圈
            while (true) {
                // 是否有足夠記憶體
                if (tryReserveMemory(size, cap)) {
                    return;
                }
                // 如果次數小于最大限定次數，終止
                if (sleeps >= MAX_SLEEPS) {
                    break;
                }
                // 再次處理penging串列中的物件
                if (!jlra.tryHandlePendingReference()) {
                    try {
                        // 睡眠一段時間
                        Thread.sleep(sleepTime);
                        sleepTime <<= 1;
                        sleeps++; // 睡眠次數增加1
                    } catch (InterruptedException e) {
                        interrupted = true;
                    }
                }
            }
            // 拋出OutOfMemoryError例外
            throw new OutOfMemoryError("Direct buffer memory");

        } finally {
            if (interrupted) {
                // don't swallow interrupts
                Thread.currentThread().interrupt();
            }
        }
    }
}

public abstract class Reference<T> {
    static {
        // ...
        // 這里設定了JavaLangRefAccess
        SharedSecrets.setJavaLangRefAccess(new JavaLangRefAccess() {
            @Override
            public boolean tryHandlePendingReference() {
                // 呼叫tryHandlePending,這里waitForNotify引數傳入的是false
                return tryHandlePending(false);
            }
        });
    }
}

參考

Reference原始碼決議

一文讀懂java中的Reference和參考型別

Java 原始碼剖析——徹底搞懂 Reference 和 ReferenceQueue

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/511032.html

標籤：其他

上一篇：Java基礎合集

下一篇：python表白玫瑰花繪制、