（*文章基於Netty4.1.22版本）
Netty記憶體管理這塊比較複雜，斷斷續續看了一個多月了，總要有點輸出，寫幾篇文章稍微分析總結一下

整體介紹

PoolChunk的結構是一顆平衡二叉樹，如下：

注：左邊代表的是節點的序號，右邊的深度，例如512號節點深度為9，其資料結構為陣列memoryMap和depthMap，初始化時相等

PoolChunk預設深度為11，一個節點預設為8KB，上圖中，最下面有Subpage這個結構，這個是用來分配小於8KB的記憶體，數量和葉子節點數一樣

舉幾個個例子來說明一下分配過程：
1.需要分配8KB的記憶體
在葉子節點尋找一個空的位置進行分配即可，此時節點的變化如下：

3個格子分別代表的意思是：深度，memoryMap[id]，depthMap[id]，在未分配前，3者是相等。
當一個節點分配之後，其memoryMap[id]=深度+1，變成右圖左下角的狀態，另外其父節點的memoryMap[id]=min(左右孩子memoryMap值)，以此類推，一直到根節點

2.需要分配16KB的記憶體
在第10層分配一個節點即可，因為其兩個孩子節點分別為8KB

那麼就有幾種分配狀態：

1. memoryMap[id] == depthMap[id]：該節點以及子節點未被分配
2. memoryMap[id] > depthMap[id]：該節點被分配 or 該節點下有一個節點被分配
3. memoryMap[id] == 深度+1：該節點被分配 or 該節點下所有孩子節點全被分配

注意，第二種情況下，不能分配16KB的記憶體，因為其子節點被分配，所剩空間不足

原始碼實現

原始碼中有大量的位運算，可能看起來不太直觀，舉個例子算一下就清晰了

初始化

    PoolChunk(PoolArena<T> arena, T memory, int pageSize, int maxOrder, int pageShifts, int chunkSize, int offset) {
        // ....省略部分賦值
        unusable = (byte) (maxOrder + 1);// unusable = 深度+1，即上面圖中的12
        maxSubpageAllocs = 1 << maxOrder;// Subpage數 2的maxOrder次方 即2048

        memoryMap = new byte[maxSubpageAllocs << 1];// maxSubpageAllocs << 1 = 2的maxOrder+1次方，即4096
        depthMap = new byte[memoryMap.length];
        int memoryMapIndex = 1;
        // 有maxOrder層，從上往下，從左往右賦值
        for (int d = 0; d <= maxOrder; ++ d) { 
            int depth = 1 << d;// 2的d次方
            for (int p = 0; p < depth; ++ p) {
                // 每一層的深度都是d，賦值給memoryMap和depthMap，所以depthMap和memoryMap初始化時是相同的
                memoryMap[memoryMapIndex] = (byte) d;
                depthMap[memoryMapIndex] = (byte) d;
                memoryMapIndex ++;
            }
        }
        // 初始化subpage
        subpages = newSubpageArray(maxSubpageAllocs);
    }

分配

    long allocate(int normCapacity) {
        if ((normCapacity & subpageOverflowMask) != 0) { // >= pageSize
            return allocateRun(normCapacity);
        } else {
            return allocateSubpage(normCapacity);
        }
    }

分配方法有兩個分支流程，一個是大於8KB的，走poolChunk，小於8KB的，走Subpage

allocateRun

    private long allocateRun(int normCapacity) {
        // 根據需要的空間，計算應該在哪一層分配
        int d = maxOrder - (log2(normCapacity) - pageShifts);
        int id = allocateNode(d);//從該深度的節點中，找出一個空閒的節點
        if (id < 0) {
            return id;
        }
        freeBytes -= runLength(id);//計算該節點所佔記憶體並減去，freeBytes為剩餘空閒記憶體
        return id;
    }

由於一個Chunk為8KB，即8192，即2的13次方，所以pageShitfs為13。
至於 maxOrder - (log2(normCapacity) - pageShifts); 怎麼理解呢，由於normCapacity在外層傳入的時候就已經做過糾正，其值為2的N次方，那麼假設normCapacity為8KB，log2(normCapacity)為13，減去pageShifts，最後算出來的就是maxOrder層，以此類推

allocateNode

    private int allocateNode(int d) {
        int id = 1;
        int initial = - (1 << d); // has last d bits = 0 and rest all = 1
        byte val = value(id);// memoryMap[id]
        if (val > d) { // 一開始說的第二種分配狀態
            return -1;
        }
        while (val < d || (id & initial) == 0) { // id & initial == 1 << d for all ids at depth d, for < d it is 0
            id <<= 1;// 2 4 6 8 .... 512 1024 2048，即在樹中最左邊的那條路徑
            val = value(id);
            if (val > d) {// 即memoryMap[id] > depthMap[id]：該節點被分配 or 該節點下有一個節點被分配
                id ^= 1;// 兄弟節點
                val = value(id);
            }
        }
        byte value = value(id);
        assert value == d && (id & initial) == 1 << d : String.format("val = %d, id & initial = %d, d = %d",
                value, id & initial, d);
        setValue(id, unusable); // 將該節點的memoryMap設定為深度+1，表示分配
        updateParentsAlloc(id);// 將父節點設定為其孩子節點memoryMap最小的那個值
        return id;
    }

大概的流程就是：

1. 先從最左邊的葉子節點匹配，如果該節點為分配，則分配該節點
2. 如果該節點已分配，那麼判斷兄弟節點是否分配，如果未分配，則分配該節點
3. 如果兄弟節點已經分配，那麼從父節點的兄弟節點的孩子節點繼續該過程

總的就是在一層中從左往右尋找匹配節點，其中兄弟節點的獲取是id^1，剛好就是兄弟節點的值

釋放

    void free(long handle) {
        int memoryMapIdx = memoryMapIdx(handle);// 將long型別的轉換成int，即保留低位資訊
        int bitmapIdx = bitmapIdx(handle);//id >>> Integer.SIZE，右移32位，高位補0

        if (bitmapIdx != 0) { // 如果是Chunk分配的，右移後，bitmapIdx會變成0，具體原因要看下Page的分析
            //獲取對應的Page
            PoolSubpage<T> subpage = subpages[subpageIdx(memoryMapIdx)];
            assert subpage != null && subpage.doNotDestroy;
        
            PoolSubpage<T> head = arena.findSubpagePoolHead(subpage.elemSize);
            synchronized (head) {
                //呼叫Page的釋放方法
                if (subpage.free(head, bitmapIdx & 0x3FFFFFFF)) {
                    return;
                }
            }
        }
        freeBytes += runLength(memoryMapIdx);
        // 和分配是逆過程
        setValue(memoryMapIdx, depth(memoryMapIdx));
        updateParentsFree(memoryMapIdx);
    }