谈一谈 Netty 的内存管理 —— 且看 Netty 如何实现 Java 版的 Jemalloc

public class PooledByteBufAllocator {    // 默认 HeapArena 的个数    private static final int DEFAULT_NUM_HEAP_ARENA;    // 默认 DirectArena 的个数    private static final int DEFAULT_NUM_DIRECT_ARENA;    static {        // PoolArena 的默认个数为 availableProcessors * 2        final int defaultMinNumArena = NettyRuntime.availableProcessors() * 2;        DEFAULT_NUM_HEAP_ARENA = Math.max(0,                SystemPropertyUtil.getInt(                        "io.netty.allocator.numHeapArenas",                        (int) Math.min(                                defaultMinNumArena,                                runtime.maxMemory() / defaultChunkSize / 2 / 3)));
        DEFAULT_NUM_DIRECT_ARENA = Math.max(0,                SystemPropertyUtil.getInt(                        "io.netty.allocator.numDirectArenas",                        (int) Math.min(                                defaultMinNumArena,                                PlatformDependent.maxDirectMemory() / defaultChunkSize / 2 / 3)));    }}

       DEFAULT_USE_CACHE_FOR_ALL_THREADS = SystemPropertyUtil.getBoolean(                "io.netty.allocator.useCacheForAllThreads", false);

// 8kint defaultPageSize = SystemPropertyUtil.getInt("io.netty.allocator.pageSize", 8192);// 4Kprivate static final int MIN_PAGE_SIZE = 4096;

// 9int defaultMaxOrder = SystemPropertyUtil.getInt("io.netty.allocator.maxOrder", 9);
// 8196 << 9 = 4Mfinal int defaultChunkSize = DEFAULT_PAGE_SIZE << DEFAULT_MAX_ORDER;
// 1Gprivate static final int MAX_CHUNK_SIZE = (int) (((long) Integer.MAX_VALUE + 1) / 2);

abstract class PoolArena<T> {    enum SizeClass {        Small,        Normal    }}

struct zone {    // 伙伴系统的核心数据结构    struct free_area    free_area[MAX_ORDER];}

struct free_area { struct list_head free_list[MIGRATE_TYPES];};
struct list_head {    // 双向链表    struct list_head *next, *prev;};

final class PoolChunk<T> implements PoolChunkMetric {    // Netty 的伙伴系统结构    private final IntPriorityQueue[] runsAvail;}

abstract class PoolArena<T> {  // 管理 Small 规格内存块的核心数据结构  final PoolSubpage<T>[] smallSubpagePools;}

struct kmem_cache *kmalloc_caches[NR_KMALLOC_TYPES][KMALLOC_SHIFT_HIGH + 1]；

abstract class PoolArena<T> {    // 分配 Page 级别的内存块    private void allocateNormal(PooledByteBuf<T> buf, int reqCapacity, int sizeIdx, PoolThreadCache threadCache) {        assert lock.isHeldByCurrentThread();        // PoolChunkList 内存分配的优先级：q050 > q025 > q000 > qInit > q075        if (q050.allocate(buf, reqCapacity, sizeIdx, threadCache) ||            q025.allocate(buf, reqCapacity, sizeIdx, threadCache) ||            q000.allocate(buf, reqCapacity, sizeIdx, threadCache) ||            qInit.allocate(buf, reqCapacity, sizeIdx, threadCache) ||            q075.allocate(buf, reqCapacity, sizeIdx, threadCache)) {            return;        }
        // 5 个 PoolChunkList 中没有可用的 PoolChunk，重新向 OS 申请一个新的 PoolChunk（4M）        PoolChunk<T> c = newChunk(sizeClass.pageSize, sizeClass.nPSizes, sizeClass.pageShifts, sizeClass.chunkSize);        // 从新的 PoolChunk 中分配内存        boolean success = c.allocate(buf, reqCapacity, sizeIdx, threadCache);        assert success;        // 将刚刚创建的 PoolChunk 加入到 qInit 中        qInit.add(c);    }}

public class PooledByteBufAllocator {    public static final PooledByteBufAllocator DEFAULT =            new PooledByteBufAllocator(PlatformDependent.directBufferPreferred());}

    private final PoolThreadLocalCache threadCache;    private final int smallCacheSize;    private final int normalCacheSize;    private final int chunkSize;    // 保存所有 DirectArena    private final PoolArena<ByteBuffer>[] directArenas;
    public PooledByteBufAllocator(boolean preferDirect, int nHeapArena, int nDirectArena, int pageSize, int maxOrder,                                  int smallCacheSize, int normalCacheSize,                                  boolean useCacheForAllThreads, int directMemoryCacheAlignment) {        // 默认偏向于分配 Direct Memory        super(preferDirect);        // 创建 PoolThreadLocalCache ，后续用于将线程与 PoolArena 绑定        // 并为线程创建 PoolThreadCache        threadCache = new PoolThreadLocalCache(useCacheForAllThreads);        // PoolThreadCache 中，针对每一个 Small 规格的尺寸可以缓存 256 个内存块        this.smallCacheSize = smallCacheSize;        // PoolThreadCache 中，针对每一个 Normal 规格的尺寸可以缓存 64 个内存块        this.normalCacheSize = normalCacheSize;        // PoolChunk 的尺寸        // pageSize << maxOrder = 4M        chunkSize = validateAndCalculateChunkSize(pageSize, maxOrder);        // 13 ， pageSize 为 8K        int pageShifts = validateAndCalculatePageShifts(pageSize, directMemoryCacheAlignment);        // 依次创建 nDirectArena 个 DirectArena（省略 HeapArena）        if (nDirectArena > 0) {            // 创建 PoolArena 数组，个数为 2 * processors            directArenas = newArenaArray(nDirectArena);            // 划分内存规格，建立内存规格索引表            final SizeClasses sizeClasses = new SizeClasses(pageSize, pageShifts, chunkSize,                    directMemoryCacheAlignment);            // 初始化 PoolArena 数组            for (int i = 0; i < directArenas.length; i ++) {                // 创建 DirectArena                PoolArena.DirectArena arena = new PoolArena.DirectArena(this, sizeClasses);                // 保存在 directArenas 数组中                directArenas[i] = arena;            }        } else {            directArenas = null;        }    }

    private final class PoolThreadLocalCache extends FastThreadLocal<PoolThreadCache> {        private final boolean useCacheForAllThreads;
        PoolThreadLocalCache(boolean useCacheForAllThreads) {            this.useCacheForAllThreads = useCacheForAllThreads;        }
        @Override        protected synchronized PoolThreadCache initialValue() {            实现线程与 PoolArena 之间的绑定            为线程创建本地缓存 PoolThreadCache        }    }

    private static <T> PoolArena<T>[] newArenaArray(int size) {        return new PoolArena[size];    }

abstract class PoolArena<T> {    // Small 规格的内存块组织在这里，类似内核的 kmalloc    final PoolSubpage<T>[] smallSubpagePools;    // 按照不同内存使用率组织 PoolChunk    private final PoolChunkList<T> q050;  // [50% , 100%)     private final PoolChunkList<T> q025;  // [25% , 75%)     private final PoolChunkList<T> q000;  // [1% , 50%)    private final PoolChunkList<T> qInit; // [0% , 25%)     private final PoolChunkList<T> q075;  // [75% , 100%)    private final PoolChunkList<T> q100;  // 100%
    protected PoolArena(PooledByteBufAllocator parent, SizeClasses sizeClass) {        // PoolArena 所属的 PooledByteBufAllocator        this.parent = parent;        // Netty 内存规格索引表        this.sizeClass = sizeClass;        // small 内存规格将会在这里分配 —— 类似 kmalloc        // 每一种 small 内存规格都会对应一个 PoolSubpage 链表（类似 slab）        smallSubpagePools = newSubpagePoolArray(sizeClass.nSubpages);        for (int i = 0; i < smallSubpagePools.length; i ++) {            // smallSubpagePools 数组中的每一项是一个带有头结点的 PoolSubpage 结构双向链表            // 双向链表的头结点是 SubpagePoolHead            smallSubpagePools[i] = newSubpagePoolHead(i);        }
        // 按照不同内存使用率范围划分 PoolChunkList        q100 = new PoolChunkList<T>(this, null, 100, Integer.MAX_VALUE, sizeClass.chunkSize);// [100 , 2147483647]        q075 = new PoolChunkList<T>(this, q100, 75, 100, sizeClass.chunkSize);        q050 = new PoolChunkList<T>(this, q075, 50, 100, sizeClass.chunkSize);        q025 = new PoolChunkList<T>(this, q050, 25, 75, sizeClass.chunkSize);        q000 = new PoolChunkList<T>(this, q025, 1, 50, sizeClass.chunkSize);        qInit = new PoolChunkList<T>(this, q000, Integer.MIN_VALUE, 25, sizeClass.chunkSize);// [-2147483648 , 25]        // 双向链表组织 PoolChunkList        // 其中比较特殊的是 q000 的前驱节点指向 NULL        // qInit 的前驱节点指向它自己        q100.prevList(q075);        q075.prevList(q050);        q050.prevList(q025);        q025.prevList(q000);        q000.prevList(null);        qInit.prevList(qInit);    }}

    private PoolSubpage<T>[] newSubpagePoolArray(int size) {        return new PoolSubpage[size];    }

    private PoolSubpage<T> newSubpagePoolHead(int index) {        PoolSubpage<T> head = new PoolSubpage<T>(index);        head.prev = head;        head.next = head;        return head;    }

short[][] sizeClasses

    private static final int LOG2GROUP_IDX = 1;    private static final int LOG2DELTA_IDX = 2;    private static final int NDELTA_IDX = 3;    private static final int PAGESIZE_IDX = 4;    private static final int SUBPAGE_IDX = 5;    private static final int LOG2_DELTA_LOOKUP_IDX = 6;

    private static int calculateSize(int log2Group, int nDelta, int log2Delta) {        return (1 << log2Group) + (nDelta << log2Delta);    }

final class SizeClasses {    // 第一种内存规格的基准 size  —— 16B     // 以及第一个内存规格增长间距 —— 16B    static final int LOG2_QUANTUM = 4;    // 每个内存规格组内，规格的个数 —— 4 个    private static final int LOG2_SIZE_CLASS_GROUP = 2;    // size2idxTab 中索引的最大内存规格 —— 4K    private static final int LOG2_MAX_LOOKUP_SIZE = 12;}

// 22 - 4 -2 + 1 = 17int group = log2(chunkSize) - LOG2_QUANTUM - LOG2_SIZE_CLASS_GROUP + 1;

    SizeClasses(int pageSize, int pageShifts, int chunkSize, int directMemoryCacheAlignment) {        // 一共分为 17 个内存规格组        int group = log2(chunkSize) - LOG2_QUANTUM - LOG2_SIZE_CLASS_GROUP + 1;
        // 创建内存规格表 sizeClasses        // 每个内存规格组内有 4 个规格，一共 68 个内存规格，一维数组长度为 68        // 二维数组的长度为 7        // 保存的内存规格信息为：index, log2Group, log2Delta, nDelta, isMultiPageSize, isSubPage, log2DeltaLookup        short[][] sizeClasses = new short[group << LOG2_SIZE_CLASS_GROUP][7];
        int normalMaxSize = -1;        // 内存规格 index , 初始为 0         int nSizes = 0;        // 内存规格 size         int size = 0;        // 第一组内存规格的基准 size 为 16B        int log2Group = LOG2_QUANTUM;        // 第一组内存规格之间的间隔为 16B        int log2Delta = LOG2_QUANTUM;        // 每个内存规格组内限定为 4 个规格        int ndeltaLimit = 1 << LOG2_SIZE_CLASS_GROUP;
        // 初始化第一个内存规格组 [16B , 64B]，nDelta 从 0 开始        for (int nDelta = 0; nDelta < ndeltaLimit; nDelta++, nSizes++) {            // 初始化对应内存规格的 7 个信息            short[] sizeClass = newSizeClass(nSizes, log2Group, log2Delta, nDelta, pageShifts);            // nSizes 为该内存规格的 index            sizeClasses[nSizes] = sizeClass;            // 通过 sizeClass 计算该内存规格的 size ,然后将 size 向上对齐至 directMemoryCacheAlignment 的最小整数倍            size = sizeOf(sizeClass, directMemoryCacheAlignment);        }
        // 每个内存规格组内的最后一个规格，往往是下一个内存规格组的基准 size        // 比如第一个内存规格组内最后一个规格 64B ， 它是第二个内存规格组的基准 size        // 4 + 2 = 6，第二个内存规格组的基准 size 为 64B        log2Group += LOG2_SIZE_CLASS_GROUP;
        // 初始化剩下的 16 个内存规格组        // 后一个内存规格组的 log2Group，log2Delta 比前一个内存规格组的 log2Group ，log2Delta 多 1        for (; size < chunkSize; log2Group++, log2Delta++) {            // 每个内存规格组内的 nDelta 从 1 到 4 ，最大内存规格不能超过 chunkSize（4M）            for (int nDelta = 1; nDelta <= ndeltaLimit && size < chunkSize; nDelta++, nSizes++) {                // 初始化对应内存规格的 7 个信息                short[] sizeClass = newSizeClass(nSizes, log2Group, log2Delta, nDelta, pageShifts);                // nSizes 为该内存规格的 index                sizeClasses[nSizes] = sizeClass;                size = normalMaxSize = sizeOf(sizeClass, directMemoryCacheAlignment);            }        }
        // 最大内存规格不能超过 chunkSize（4M）        // 超过 4M 就是 Huge 内存规格，直接分配不进行池化管理        assert chunkSize == normalMaxSize;
              ...... 省略 ......    }

short[][] sizeClasses = new short[group << LOG2_SIZE_CLASS_GROUP][7];

// 4 + 2 = 6log2Group += LOG2_SIZE_CLASS_GROUP;

    private static short[] newSizeClass(int index, int log2Group, int log2Delta, int nDelta, int pageShifts) {        // 判断规格尺寸是否是 Page 的整数倍        short isMultiPageSize;        if (log2Delta >= pageShifts) {            // 尺寸按照 Page 的倍数递增了，那么一定是  Page 的整数倍            isMultiPageSize = yes;        } else {            int pageSize = 1 << pageShifts;            // size = 1 << log2Group + nDelta * (1 << log2Delta)            int size = calculateSize(log2Group, nDelta, log2Delta);            // 是否能被 pagesize(8k) 整除            isMultiPageSize = size == size / pageSize * pageSize? yes : no;        }        // 规格尺寸小于 32K ，那么就属于 Small 规格，对应的内存块会被 PoolSubpage 管理        short isSubpage = log2Size < pageShifts + LOG2_SIZE_CLASS_GROUP? yes : no;
        // 如果内存规格 size 小于等于 MAX_LOOKUP_SIZE（4K），那么 log2DeltaLookup 为 log2Delta        // 如果内存规格 size 大于 MAX_LOOKUP_SIZE（4K），则为 0        // Netty 只会为 4K 以下的内存规格建立 size2idxTab 索引        int log2DeltaLookup = log2Size < LOG2_MAX_LOOKUP_SIZE ||                              log2Size == LOG2_MAX_LOOKUP_SIZE && remove == no                ? log2Delta : no;        // 初始化内存规格信息        return new short[] {                (short) index, (short) log2Group, (short) log2Delta,                (short) nDelta, isMultiPageSize, isSubpage, (short) log2DeltaLookup        };    }

        // Small 规格中最大的规格尺寸对应的 index (38)        int smallMaxSizeIdx = 0;        // size2idxTab 中最大的 lookup size （4K）        int lookupMaxSize = 0;        // Page 级别内存规格的个数（32）        int nPSizes = 0;        // Small 内存规格的个数（39）        int nSubpages = 0;        // 遍历内存规格表 sizeClasses，统计 nPSizes ， nSubpages，smallMaxSizeIdx，lookupMaxSize        for (int idx = 0; idx < nSizes; idx++) {            short[] sz = sizeClasses[idx];            // 只要 size 可以被 pagesize 整除，那么就属于 MultiPageSize            if (sz[PAGESIZE_IDX] == yes) {                nPSizes++;            }            // 只要 size 小于 32K 则为 Subpage 的规格            if (sz[SUBPAGE_IDX] == yes) {                nSubpages++;                // small 内存规格中的最大尺寸 28K ，对应的 sizeIndex = 38                smallMaxSizeIdx = idx;            }            // 内存规格小于等于 4K 的都属于 lookup size            if (sz[LOG2_DELTA_LOOKUP_IDX] != no) {                // 4K                lookupMaxSize = sizeOf(sz, directMemoryCacheAlignment);            }        }        // 38        this.smallMaxSizeIdx = smallMaxSizeIdx;        // 4086(4K)        this.lookupMaxSize = lookupMaxSize;        // 32        this.nPSizes = nPSizes;        // 39        this.nSubpages = nSubpages;        // 68        this.nSizes = nSizes;        // 8192(8K)        this.pageSize = pageSize;        // 13        this.pageShifts = pageShifts;        // 4M        this.chunkSize = chunkSize;        // 0        this.directMemoryCacheAlignment = directMemoryCacheAlignment;

        // sizeIndex 与 size 之间的映射        this.sizeIdx2sizeTab = newIdx2SizeTab(sizeClasses, nSizes, directMemoryCacheAlignment);        // 根据 sizeClass 生成 page 级的内存规格表        // pageIndex 到对应的 size 之间的映射        this.pageIdx2sizeTab = newPageIdx2sizeTab(sizeClasses, nSizes, nPSizes, directMemoryCacheAlignment);        // 4k 之内，给定一个 size 转换为 sizeIndex        this.size2idxTab = newSize2idxTab(lookupMaxSize, sizeClasses);

    private static int[] newIdx2SizeTab(short[][] sizeClasses, int nSizes, int directMemoryCacheAlignment) {        // 68 种内存规格，映射条目也是 68        int[] sizeIdx2sizeTab = new int[nSizes];        // 遍历内存规格表，建立 index 与规格 size 之间的映射        for (int i = 0; i < nSizes; i++) {            short[] sizeClass = sizeClasses[i];            // size = 1 << log2Group + nDelta * (1 << log2Delta)            sizeIdx2sizeTab[i] = sizeOf(sizeClass, directMemoryCacheAlignment);        }        return sizeIdx2sizeTab;    }

    private static int[] newPageIdx2sizeTab(short[][] sizeClasses, int nSizes, int nPSizes,                                            int directMemoryCacheAlignment) {        // page 级的内存规格，个数为 32        int[] pageIdx2sizeTab = new int[nPSizes];        int pageIdx = 0;        // 遍历内存规格表，建立 pageIdx 与对应 Page 级内存规格 size 之间的映射        for (int i = 0; i < nSizes; i++) {            short[] sizeClass = sizeClasses[i];            if (sizeClass[PAGESIZE_IDX] == yes) {                pageIdx2sizeTab[pageIdx++] = sizeOf(sizeClass, directMemoryCacheAlignment);            }        }        return pageIdx2sizeTab;    }

int[] size2idxTab

 // 基础内存规格 static final int LOG2_QUANTUM = 4;

lookupSize - 1 >> LOG2_QUANTUM

    private static int[] newSize2idxTab(int lookupMaxSize, short[][] sizeClasses) {        // size2idxTab 中的 lookupSize 按照 16 依次递增，最大为 4K        // 因此 size2idxTab 大小为 4K / 16        int[] size2idxTab = new int[lookupMaxSize >> LOG2_QUANTUM];        // lookupIndex        int idx = 0;        // lookupSize        int size = 0;        // 遍历 4K 以下的内存规格表 sizeClasses，建立 size2idxTab        for (int i = 0; size <= lookupMaxSize; i++) {            int log2Delta = sizeClasses[i][LOG2DELTA_IDX];            // 计算规格之间的差值是 16 的几倍            // 比如 sizeIndex 7 和 8 对应的内存规格之间差值是 32 （2 * 16）            // 那么这两个内存规格之间就需要划分出 times 个 lookupSize            int times = 1 << log2Delta - LOG2_QUANTUM;            // 构建 size2idxTab            while (size <= lookupMaxSize && times-- > 0) {                // lookupIndex 与 sizeIndex 之间的映射                size2idxTab[idx++] = i;                // lookupSize 按照 16 依次递增                size = idx + 1 << LOG2_QUANTUM;            }        }        return size2idxTab;    }

// 组内最后一个内存规格的对数int x = log2((lookupSize << 1) - 1);

// lookupSize 所在内存规格组编号int shift = x - (LOG2_SIZE_CLASS_GROUP + LOG2_QUANTUM)

// 组内第一个规格的 indexint group = shift << LOG2_SIZE_CLASS_GROUP;

// 组内规格间隔int log2Delta =  x - LOG2_SIZE_CLASS_GROUP - 1;

int mod = lookupSize - 1 >> log2Delta & (1 << LOG2_SIZE_CLASS_GROUP) - 1;

final class SizeClasses {
    @Override    public int size2SizeIdx(int size) {        if (size == 0) {            return 0;        }        // Netty 只会池化 4M 以下的内存块        if (size > chunkSize) {            return nSizes;        }        // 将 lookupSize 与 Alignment 进行对齐        size = alignSizeIfNeeded(size, directMemoryCacheAlignment);        // lookupSize 在 4K 以下直接去 size2idxTab 中去查        if (size <= lookupMaxSize) {            return size2idxTab[size - 1 >> LOG2_QUANTUM];        }        // 向上取 size 最接近的 2 的次幂，目的是获取所属内存规格组的最后一个规格尺寸        int x = log2((size << 1) - 1);        // size 所在内存规格组编号，最后一个规格尺寸除以 64 得到商的对数        int shift = x < LOG2_SIZE_CLASS_GROUP + LOG2_QUANTUM + 1                ? 0 : x - (LOG2_SIZE_CLASS_GROUP + LOG2_QUANTUM);        // 内存规格组内第一个规格 index        int group = shift << LOG2_SIZE_CLASS_GROUP;        // 组内规格之间的间隔        int log2Delta = x < LOG2_SIZE_CLASS_GROUP + LOG2_QUANTUM + 1                ? LOG2_QUANTUM : x - LOG2_SIZE_CLASS_GROUP - 1;        // size 最贴近组内哪一个规格        int mod = size - 1 >> log2Delta & (1 << LOG2_SIZE_CLASS_GROUP) - 1;        // 返回对应内存规格 index        return group + mod;    }}

static final class DirectArena extends PoolArena<ByteBuffer> {        @Override        protected PoolChunk<ByteBuffer> newChunk(int pageSize, int maxPageIdx,            int pageShifts, int chunkSize) {            if (sizeClass.directMemoryCacheAlignment == 0) {                // 分配一个 4M 大小的 DirectByteBuffer                ByteBuffer memory = allocateDirect(chunkSize);                // 创建 PoolChunk，管理这 4M 的内存空间                return new PoolChunk<ByteBuffer>(this, memory, memory, pageSize, pageShifts,                        chunkSize, maxPageIdx);            }            // 如果是需要按照指定的 Alignment 对齐的话            // 则申请 4M +  directMemoryCacheAlignment 大小的 DirectByteBuffer            final ByteBuffer base = allocateDirect(chunkSize + sizeClass.directMemoryCacheAlignment);            // 将 DirectByteBuffer 的 position 位置与 directMemoryCacheAlignment 对齐            final ByteBuffer memory = PlatformDependent.alignDirectBuffer(base, sizeClass.directMemoryCacheAlignment);            // 地址对齐之后，创建 PoolChunk            return new PoolChunk<ByteBuffer>(this, base, memory, pageSize,                    pageShifts, chunkSize, maxPageIdx);        }}

final class PoolChunk<T> {    // PoolChunk 底层依赖的这 4M 内存空间用 JDK 的 ByteBuffer 包装    final Object base;    // 内存地址对齐之后的 ByteBuffer    final T memory;}

 private final IntPriorityQueue[] runsAvail;

 private static final int SIZE_BIT_LENGTH = 15;

private static final int INUSED_BIT_LENGTH = 1;

private static final int SUBPAGE_BIT_LENGTH = 1;

private static final int BITMAP_IDX_BIT_LENGTH = 32;

    static final int IS_SUBPAGE_SHIFT = BITMAP_IDX_BIT_LENGTH;    static final int IS_USED_SHIFT = SUBPAGE_BIT_LENGTH + IS_SUBPAGE_SHIFT;    static final int SIZE_SHIFT = INUSED_BIT_LENGTH + IS_USED_SHIFT;    static final int RUN_OFFSET_SHIFT = SIZE_BIT_LENGTH + SIZE_SHIFT;

    static int runOffset(long handle) {        return (int) (handle >> RUN_OFFSET_SHIFT);    }
    static int runPages(long handle) {        return (int) (handle >> SIZE_SHIFT & 0x7fff);    }
    static boolean isUsed(long handle) {        return (handle >> IS_USED_SHIFT & 1) == 1L;    }
    static boolean isSubpage(long handle) {        return (handle >> IS_SUBPAGE_SHIFT & 1) == 1L;    }
    static int bitmapIdx(long handle) {        return (int) handle;    }

    private static long toRunHandle(int runOffset, int runPages, int inUsed) {        return (long) runOffset << RUN_OFFSET_SHIFT               | (long) runPages << SIZE_SHIFT               | (long) inUsed << IS_USED_SHIFT;    }

    private long toHandle(int bitmapIdx) {        // subPage 中包含的 page 个数        int pages = runSize >> pageShifts;        // 低 32 位保存 bitmapIdx        return (long) runOffset << RUN_OFFSET_SHIFT               | (long) pages << SIZE_SHIFT               | 1L << IS_USED_SHIFT               | 1L << IS_SUBPAGE_SHIFT               | bitmapIdx;    }

 private final IntPriorityQueue[] runsAvail;

    // 参数 size 就是 SizeClasses 中计算出的 nPSizes，共 32 种 Run 尺寸    private static IntPriorityQueue[] newRunsAvailqueueArray(int size) {        IntPriorityQueue[] queueArray = new IntPriorityQueue[size];        for (int i = 0; i < queueArray.length; i++) {            queueArray[i] = new IntPriorityQueue();        }        return queueArray;    }

 private final LongLongHashMap runsAvailMap;

    private long collapseRuns(long handle) {        // 在 PoolChunk 中首先不断地向前合并与 handle 内存连续的 Run        // 然后在不断地向后合并内存连续的 Run，最终形成一个更大的 Run 存储到 runsAvail 中        return collapseNext(collapsePast(handle));    }

int runOffset = runOffset(handle);long pastRun = getAvailRunByOffset(runOffset - 1);

           // 白色 Run 的 size (包含 Page 的个数)           int runPages = runPages(handle);           // 绿色 Run 的 runOffset           int pastOffset = runOffset(pastRun);           // 绿色 Run 的 size           int pastPages = runPages(pastRun);
           if (pastRun != handle && pastOffset + pastPages == runOffset) {                // 清除绿色 Run 在 runsAvailMap 中的相关索引                removeAvailRun(pastRun);                // 白色，绿色合并成一个更大的 Run,                // 新的 runOffset 为绿色 Run 的 runOffset                // 新的 size 为两者之和                handle = toRunHandle(pastOffset, pastPages + runPages, 0);            }

    private long collapsePast(long handle) {        // 不断地向前合并内存连续的 Run        for (;;) {            // 释放内存块的 runOffset            int runOffset = runOffset(handle);            // 释放内存块 size （包含 Page 的个数）            int runPages = runPages(handle);            // 查看该内存块前面是否有连续的 Run            // 如果有 pastRun 中的 lastPageOffset 一定是 runOffset - 1            long pastRun = getAvailRunByOffset(runOffset - 1);            if (pastRun == -1) {                // 前面不存在连续的 Run 则停止向前合并                return handle;            }            // 连续内存块的 runOffset            int pastOffset = runOffset(pastRun);            // 连续内存块的 size            int pastPages = runPages(pastRun);
            // is continuous            if (pastRun != handle && pastOffset + pastPages == runOffset) {                // 将 pastRun 在 runsAvailMap 中的相关索引删除                removeAvailRun(pastRun);                // 重新合并成一个更大的 Run                handle = toRunHandle(pastOffset, pastPages + runPages, 0);            } else {                // 前面没有连续的 Run , 停止向前合并                return handle;            }        }    }

    private long collapseNext(long handle) {        // 这里的 handle 就是向前合并之后新的 Run        // 不断的向后合并连续的 Run        for (;;) {            int runOffset = runOffset(handle);            int runPages = runPages(handle);            // 向后查找内存连续的 Run, nextRun 的 firstPageOffset = runOffset + runPages            long nextRun = getAvailRunByOffset(runOffset + runPages);            if (nextRun == -1) {                // 后面不存在内存连续的 Run                return handle;            }
            int nextOffset = runOffset(nextRun);            int nextPages = runPages(nextRun);
            //is continuous            if (nextRun != handle && runOffset + runPages == nextOffset) {                //remove next run                removeAvailRun(nextRun);                handle = toRunHandle(runOffset, runPages + nextPages, 0);            } else {                return handle;            }        }    }

    /**     * manage all subpages in this chunk     */    private final PoolSubpage<T>[] subpages;

subpages = new PoolSubpage[chunkSize >> pageShifts];

private final Deque<ByteBuffer> cachedNioBuffers;

      DEFAULT_MAX_CACHED_BYTEBUFFERS_PER_CHUNK = SystemPropertyUtil.getInt(                "io.netty.allocator.maxCachedByteBuffersPerChunk", 1023);

final class PoolChunk<T> {    // PoolChunk 底层依赖的这 4M 内存空间用 JDK 的 ByteBuffer 包装    // memory 就是 PoolChunk 底层的 ByteBuffer（4M）    final T memory;}

abstract class PooledByteBuf<T> {    int readerIndex;    int writerIndex;    // 我们向内存池请求的内存大小 , 其实就是 ByteBuf 的 capacity    protected int length;    // 内存池实际分配给我们的内存大小    int maxLength;    // PoolChunk 中 memory 的 duplicate 视图    ByteBuffer tmpNioBuf;}

    @Override    protected ByteBuffer newInternalNioBuffer(ByteBuffer memory) {        return memory.duplicate();    }

int pages = chunkSize >> pageShifts;long initHandle = (long) pages << SIZE_SHIFT;// 插入到 runsAvail 中insertAvailRun(0, pages, initHandle);

    private void insertAvailRun(int runOffset, int pages, long handle) {        // 512 个 Page 在 Page 规格表中对应的 pageIdx 为 31        int pageIdxFloor = arena.sizeClass.pages2pageIdxFloor(pages);                IntPriorityQueue queue = runsAvail[pageIdxFloor];        // 将 4M 的 Run 插入到 runsAvail[31] 中        queue.offer((int) (handle >> BITMAP_IDX_BIT_LENGTH));        // 将 Run 中第一个 Page 的 runOffset 以及最后一个 Page 的 runOffset 插入到 runsAvailMap 中        insertAvailRun0(runOffset, handle);        if (pages > 1) {            insertAvailRun0(lastPage(runOffset, pages), handle);        }    }

    private void insertAvailRun0(int runOffset, long handle) {        long pre = runsAvailMap.put(runOffset, handle);        assert pre == -1;    }

    PoolChunk(PoolArena<T> arena, Object base, T memory, int pageSize, int pageShifts, int chunkSize, int maxPageIdx) {        // 只对 4M 的 PoolChunk 进行池化        unpooled = false;        // PoolChunk 所属的 PoolArena        this.arena = arena;        // PoolChunk 底层依赖的 JDK ByteBuffer (4M)        this.base = base;        this.memory = memory;        // 8K        this.pageSize = pageSize;        // 13        this.pageShifts = pageShifts;        // 4M        this.chunkSize = chunkSize;        // PoolChunk 剩余的内存空间，初始为 4M        freeBytes = chunkSize;        // 创建 runsAvail 数组，Netty 中的伙伴系统        // index 为 PageIndex        runsAvail = newRunsAvailqueueArray(maxPageIdx);        runsAvailLock = new ReentrantLock();        // runsAvail 中所有 Run 的 first page runOffset 以及 last page runOffset        runsAvailMap = new LongLongHashMap(-1);        // 负责组织所有由这个 PoolChunk 分配出去的 PoolSubpage        // index 为 PoolSubpage 的 runOffset        subpages = new PoolSubpage[chunkSize >> pageShifts];        // PoolChunk 在初始状态下只有一个 Run        // size 为 512 个 Page（4M）        int pages = chunkSize >> pageShifts;        // 初始run : runOffset = 0 (15 bit) , size = 512(15 bits) , isUsed = 0 (1bit) , isSubpage = 0 (1bit), bitmapIdx = 0 (32bits)        long initHandle = (long) pages << SIZE_SHIFT;        // 将初始 run 插入到 runsAvail 数组中        insertAvailRun(0, pages, initHandle);        // 可缓存 1023 个 memory 的 duplicate 视图        cachedNioBuffers = new ArrayDeque<ByteBuffer>(8);    }

final boolean unpooled;

abstract class PoolArena<T> {
    private void allocate(PoolThreadCache cache, PooledByteBuf<T> buf, final int reqCapacity) {        // 获取 reqCapacity 在 sizeIdx2sizeTab 中的 index（对应的内存规格 index）        final int sizeIdx = sizeClass.size2SizeIdx(reqCapacity);        // [16B , 28K] 之间是 small 规格的内存        if (sizeIdx <= sizeClass.smallMaxSizeIdx) {            tcacheAllocateSmall(cache, buf, reqCapacity, sizeIdx);        } else if (sizeIdx < sizeClass.nSizes) {            // [32K , 4M] 之间是 normal 规格的内存            tcacheAllocateNormal(cache, buf, reqCapacity, sizeIdx);        } else {            // 超过 4M 就是 Huge 规格            int normCapacity = sizeClass.directMemoryCacheAlignment > 0                    ? sizeClass.normalizeSize(reqCapacity) : reqCapacity;            // huge 内存规格直接向操作系统申请，不会被内存池管理            allocateHuge(buf, normCapacity);        }    }}

    /** Creates a special chunk that is not pooled. */    PoolChunk(PoolArena<T> arena, Object base, T memory, int size) {        // Huge 规格的内存块不会被内存池管理        unpooled = true;        this.arena = arena;        this.base = base;        this.memory = memory;        pageSize = 0;        pageShifts = 0;        runsAvailMap = null;        runsAvail = null;        runsAvailLock = null;        subpages = null;        chunkSize = size;        cachedNioBuffers = null;    }

    private int runFirstBestFit(int pageIdx) {        // 如果该 PoolChunk 是一个全新的，那么直接就到 runsAvail[31] 中去找        // 因为此时 PoolChunk 中只会包含一个 Run （大小为 4M）        if (freeBytes == chunkSize) {            return arena.sizeClass.nPSizes - 1;        }        // 按照伙伴查找算法，先从 pageIdx 规格开始查找对应的 IntPriorityQueue 是否有内存块        // 如果没有就一直向后查找，直到找到一个不为空的 IntPriorityQueue        for (int i = pageIdx; i < arena.sizeClass.nPSizes; i++) {            IntPriorityQueue queue = runsAvail[i];            if (queue != null && !queue.isEmpty()) {                return i;            }        }        // 如果 chunk 全部分配出去了，则返回 -1        return -1;    }

        // runSize 为 8K ，一个 Page 大小        int pages = runSize >> pageShifts; // 1        // 8K 对应在 pageIdx2sizeTab 中的 pageIdx 为 0         int pageIdx = arena.sizeClass.pages2pageIdx(pages);

    // handle 表示即将要被分裂的 Run （4M）    // needPages 表示我们要申请的 Page 规格（8K）    private long splitLargeRun(long handle, int needPages) {        assert needPages > 0;        // handle 中包含的 pages 个数（512）        int totalPages = runPages(handle);        // 剩余 511 个 Page        int remPages = totalPages - needPages;
        if (remPages > 0) {            // handle 的 runOffset 为 0             int runOffset = runOffset(handle);            // 获取剩余内存块在 chunk 中的 runOffset (1)            // [runOffset , availOffset - 1] 这段内存将会被分配出去            int availOffset = runOffset + needPages; // 1            // 将剩余的内存块重新包装成 Run，runOffset = 1 ,size = 511            long availRun = toRunHandle(availOffset, remPages, 0);            // 将剩余的 run, 重新放回到伙伴系统 runsAvail 中            // 注意这里并不会向内核那样减半分裂，而是直接将 run 放回到 remPages 内存规格对应的 runsAvail 数组中            insertAvailRun(availOffset, remPages, availRun);            // 将 needPages 分配出去            return toRunHandle(runOffset, needPages, 1);        }
        // mark it as used        handle |= 1L << IS_USED_SHIFT;        return handle;    }

    // runSize 为申请的内存大小    private long allocateRun(int runSize) {        // 计算 runSize 包含多少个 pages        int pages = runSize >> pageShifts;        // 获取该 pages 尺寸对应在 pageIdx2sizeTab 中的 pageIdx        int pageIdx = arena.sizeClass.pages2pageIdx(pages);
        runsAvailLock.lock();        try {            // 按照伙伴算法，从 pageIdx 开始在 runsAvail 数组中查找第一个不为空的 IntPriorityQueue            int queueIdx = runFirstBestFit(pageIdx);            // chunk 已经没有剩余内存了，返回 -1            if (queueIdx == -1) {                return -1;            }            // 获取 queueIdx 对应内存规格的 IntPriorityQueue            IntPriorityQueue queue = runsAvail[queueIdx];            // 获取内存地址最低的一个 run, 内存尺寸为 pageIdx2sizeTab[queueIdx]            long handle = queue.poll();            assert handle != IntPriorityQueue.NO_VALUE;            // runOffset(15bits) , size(15bits) , isUsed(1bit), isSubPapge(1bit) , bitmapIndex(32bits)            handle <<= BITMAP_IDX_BIT_LENGTH;            assert !isUsed(handle) : "invalid handle: " + handle;            // 从 runsAvailMap 中删除该 run 的 offset 信息            removeAvailRun0(handle);            // 如果该 run 尺寸恰好和我们请求的 runSize 一致，那么就直接分配            // 如果该 run 尺寸大于我们请求的 runSize , 就需要将剩余的内存块放入到对应规格的 runsAvail 中            handle = splitLargeRun(handle, pages);                      int pinnedSize = runSize(pageShifts, handle);            // 相应减少 chunk 的剩余内存统计            freeBytes -= pinnedSize;            return handle;        } finally {            runsAvailLock.unlock();        }    }

    // handle 表示要释放的内存块    // nioBuffer 是 PooledByteBuf 底层依赖的 PoolChunk 中 memory 的 duplicate 视图    // PooledByteBuf 用于包装 handle 给用户使用    void free(long handle, int normCapacity, ByteBuffer nioBuffer) {             // 获取要释放内存块大小，字节为单位        int runSize = runSize(pageShifts, handle);        // start free run        runsAvailLock.lock();        try {            // 在 PoolChunk 不断的向前，向后合并连续的 Run            long finalRun = collapseRuns(handle);            // 重置 isUsed 位 = 0             finalRun &= ~(1L << IS_USED_SHIFT);            // 重置 isSubpage 位 = 0            finalRun &= ~(1L << IS_SUBPAGE_SHIFT);            // 将合并后的 finalRun 重新插入到伙伴系统中            insertAvailRun(runOffset(finalRun), runPages(finalRun), finalRun);            // 更新 PoolChunk 剩余内存的统计计数            freeBytes += runSize;        } finally {            runsAvailLock.unlock();        }        // 将 nioBuffer 缓存到 cachedNioBuffers 中        if (nioBuffer != null && cachedNioBuffers != null &&            cachedNioBuffers.size() < PooledByteBufAllocator.DEFAULT_MAX_CACHED_BYTEBUFFERS_PER_CHUNK) {            // 默认可以缓存 1023 个 nioBuffer（全部都是 PoolChunk 的 duplicates 视图）            cachedNioBuffers.offer(nioBuffer);        }    }

abstract class PoolArena<T> {    // 按照不同内存使用率组织 PoolChunk    private final PoolChunkList<T> q050;  // [50% , 100%)     private final PoolChunkList<T> q025;  // [25% , 75%)     private final PoolChunkList<T> q000;  // [1% , 50%)    private final PoolChunkList<T> qInit; // [0% , 25%)     private final PoolChunkList<T> q075;  // [75% , 100%)    private final PoolChunkList<T> q100;  // 100%}

final class PoolChunkList<T> {    // 头指针，指向 List 中第一个 PoolChunk    private PoolChunk<T> head;    // 指向前一个 PoolChunkList    private PoolChunkList<T> prevList;    // 指向后一个 PoolChunkList    private final PoolChunkList<T> nextList;}

    protected PoolArena(PooledByteBufAllocator parent, SizeClasses sizeClass) {        // 按照不同内存使用率范围划分 PoolChunkList        q100 = new PoolChunkList<T>(this, null, 100, Integer.MAX_VALUE, sizeClass.chunkSize);// [100 , 2147483647]        q075 = new PoolChunkList<T>(this, q100, 75, 100, sizeClass.chunkSize);        q050 = new PoolChunkList<T>(this, q075, 50, 100, sizeClass.chunkSize);        q025 = new PoolChunkList<T>(this, q050, 25, 75, sizeClass.chunkSize);        q000 = new PoolChunkList<T>(this, q025, 1, 50, sizeClass.chunkSize);        qInit = new PoolChunkList<T>(this, q000, Integer.MIN_VALUE, 25, sizeClass.chunkSize);// [-2147483648 , 25]        // 双向链表组织 PoolChunkList        // 其中比较特殊的是 q000 的前驱节点指向 NULL        // qInit 的前驱节点指向它自己        q100.prevList(q075);        q075.prevList(q050);        q050.prevList(q025);        q025.prevList(q000);        q000.prevList(null);        qInit.prevList(qInit);    }

    // minUsage 为 PoolChunkList 中内存使用率的下限，单位是百分比    // maxUsage 为 PoolChunkList 中内存使用率的上限，单位是百分比    PoolChunkList(PoolArena<T> arena, PoolChunkList<T> nextList, int minUsage, int maxUsage, int chunkSize) {        // 所属 PoolArena        this.arena = arena;        // 下一个 PoolChunkList        this.nextList = nextList;        // 该 PoolChunkList 中的 PoolChunk 内存占用率在 [minUsage , maxUsage)        // 当 PoolChunk 中的内存占用率低于 minUsage 则将它移动到前一个 PoolChunkList 中 （prevList）        // 当 PoolChunk 中的内存占用率达到 maxUsage 则将它移动到后一个 PoolChunkList 中 （nextList）        this.minUsage = minUsage;        this.maxUsage = maxUsage;        // 计算该 PoolChunkList 中的 PoolChunk 可以分配出去的最大内存容量 ,单位为 byte        // chunkSize * (100L - minUsage) / 100L)        maxCapacity = calculateMaxCapacity(minUsage, chunkSize);        // 将内存使用率的上限和下限转换成对应的阈值        // PoolChunk 停留在 PoolChunkList 中的剩余内存最低阈值，达到该阈值则向后移动到 nextList        freeMinThreshold = (maxUsage == 100) ? 0 : (int) (chunkSize * (100.0 - maxUsage + 0.99999999) / 100L);        // PoolChunk 停留在 PoolChunkList 中的剩余内存最高阈值，高于该阈值则向前移动到 prevList        freeMaxThreshold = (minUsage == 100) ? 0 : (int) (chunkSize * (100.0 - minUsage + 0.99999999) / 100L);    }

abstract class PoolArena<T> {    private void allocateNormal(PooledByteBuf<T> buf, int reqCapacity, int sizeIdx, PoolThreadCache threadCache) {        if (q050.allocate(buf, reqCapacity, sizeIdx, threadCache) ||            q025.allocate(buf, reqCapacity, sizeIdx, threadCache) ||            q000.allocate(buf, reqCapacity, sizeIdx, threadCache) ||            qInit.allocate(buf, reqCapacity, sizeIdx, threadCache) ||            q075.allocate(buf, reqCapacity, sizeIdx, threadCache)) {            return;        }
        // Add a new chunk.        PoolChunk<T> c = newChunk(sizeClass.pageSize, sizeClass.nPSizes, sizeClass.pageShifts, sizeClass.chunkSize);        boolean success = c.allocate(buf, reqCapacity, sizeIdx, threadCache);        qInit.add(c);    }}

final class PoolChunkList<T> {    boolean allocate(PooledByteBuf<T> buf, int reqCapacity, int sizeIdx, PoolThreadCache threadCache) {        int normCapacity = arena.sizeClass.sizeIdx2size(sizeIdx);        if (normCapacity > maxCapacity) {            // 申请的内存尺寸太大，本 PoolChunkList 无法满足            return false;        }        // 挨个遍历 PoolChunkList 中的 PoolChunk，直到内存分配成功        for (PoolChunk<T> cur = head; cur != null; cur = cur.next) {            if (cur.allocate(buf, reqCapacity, sizeIdx, threadCache)) {                // PoolChunk 的剩余内存达到最小阈值，则向后移动                if (cur.freeBytes <= freeMinThreshold) {                    remove(cur);                    nextList.add(cur);                }                return true;            }        }        // 内存分配失败        return false;    }}

    private void remove(PoolChunk<T> cur) {        if (cur == head) {            head = cur.next;            if (head != null) {                head.prev = null;            }        } else {            PoolChunk<T> next = cur.next;            cur.prev.next = next;            if (next != null) {                next.prev = cur.prev;            }        }    }

    void add(PoolChunk<T> chunk) {        if (chunk.freeBytes <= freeMinThreshold) {            nextList.add(chunk);            return;        }        add0(chunk);    }

    void add0(PoolChunk<T> chunk) {        chunk.parent = this;        if (head == null) {            head = chunk;            chunk.prev = null;            chunk.next = null;        } else {            chunk.prev = null;            chunk.next = head;            head.prev = chunk;            head = chunk;        }    }

final class PoolChunkList<T> {    boolean free(PoolChunk<T> chunk, long handle, int normCapacity, ByteBuffer nioBuffer) {        // 内存块 handle 释放回 PoolChunk        chunk.free(handle, normCapacity, nioBuffer);        // PoolChunk 中的内存使用率低于该 PoolChunkList 的下限        if (chunk.freeBytes > freeMaxThreshold) {            remove(chunk);            // 将 PoolChunk 移动到前一个 PoolChunkList 中            return move0(chunk);        }        return true;    }}

    private boolean move0(PoolChunk<T> chunk) {        // 该 PoolChunkList 是 q000 的情况        if (prevList == null) {            // 返回 false, 后续 Netty 会将该  PoolChunk 释放回 OS            return false;        }        // 其他情况下，PoolChunk 则向前移动        return prevList.move(chunk);    }

    private boolean move(PoolChunk<T> chunk) {          if (chunk.freeBytes > freeMaxThreshold) {            // PoolChunk 的内存使用率仍然低于 prevList 的下限，继续向前移动            return move0(chunk);        }        // PoolChunk fits into this PoolChunkList, adding it here.（头插法）        add0(chunk);        return true;    }

final class PoolSubpage<T> {    PoolSubpage<T> prev;    PoolSubpage<T> next;}

abstract class PoolArena<T> {  // 管理 Small 规格内存块的核心数据结构  final PoolSubpage<T>[] smallSubpagePools;}

    // Small 规格对应的 sizeIdx（规格 sizeIndex）    private int calculateRunSize(int sizeIdx) {        // 一个 page 最大可以容纳多少个内存块（Element）        // pageSize / 16(最小内存块尺寸)        int maxElements = 1 << pageShifts - SizeClasses.LOG2_QUANTUM;        int runSize = 0;        int nElements;        // sizeIdx 对应的内存规格，PoolSubpage 将会按照 elemSize 进行切分        final int elemSize = arena.sizeClass.sizeIdx2size(sizeIdx);        // 查找 pageSize 与 elemSize 的最小公倍数        do {            runSize += pageSize;            nElements = runSize / elemSize;        } while (nElements < maxElements && runSize != nElements * elemSize);        // PoolSubpage 切分出的内存块个数不能超过 maxElements（512）        while (nElements > maxElements) {            // runSize 太大了，缩减到 nElements <= maxElements            runSize -= pageSize;            nElements = runSize / elemSize;        }        // PoolSubpage 的最终尺寸        return runSize;    }

final class PoolChunk {
    private long allocateSubpage(int sizeIdx, PoolSubpage<T> head) {        // 计算 PoolSubpage 的尺寸，取对应的 Small 规格与 PageSize 的最小公倍数        int runSize = calculateRunSize(sizeIdx);        // 从 PoolChunk 申请一个 runSize 大小的 PoolSubpage        long runHandle = allocateRun(runSize);        if (runHandle < 0) {            return -1;        }
        int runOffset = runOffset(runHandle);        // 对应的 Small 内存规格        int elemSize = arena.sizeClass.sizeIdx2size(sizeIdx);        // 根据 runHandle 创建 PoolSubpage        PoolSubpage<T> subpage = new PoolSubpage<T>(head, this, pageShifts, runOffset,                runSize(pageShifts, runHandle), elemSize);        // 将 PoolSubpage 保存在 PoolChunk 的 subpages 数组中        subpages[runOffset] = subpage;        // 从 PoolSubpage 分配一个小内存块出去        return subpage.allocate();    }}

final class PoolSubpage {    // head 表示该 PoolSubpage 在 smallSubpagePools 对应规格链表的头结点    // 每个 PoolSubpage 链表都对应一个头结点    // elemSize 表示需要被管理的 Small 规格尺寸    PoolSubpage(PoolSubpage<T> head, PoolChunk<T> chunk, int pageShifts, int runOffset, int runSize, int elemSize) {        // 该 PoolSubpage 管理的 elemSize 对应的 sizeIndex        // 比如 16B 对应的 sizeIndex 是 0        this.headIndex = head.headIndex;        // PoolSubpage 所属的 PoolChunk        this.chunk = chunk;        // 13        this.pageShifts = pageShifts;        // PoolSubpage 在 PoolChunk 中的起始偏移（ page 粒度）        this.runOffset = runOffset;        // PoolSubpage 大小（字节单位）        this.runSize = runSize;        // PoolSubpage 管理的 Small 规格内存块大小        this.elemSize = elemSize;        doNotDestroy = true;        // PoolSubpage 管理的内存块个数        maxNumElems = numAvail = runSize / elemSize;        // 创建一个 bitmap ，用于管理 PoolSubpage 中所有小内存块的状态        // 以及索引这些小内存块在 PoolSubpage 中的位置        int bitmapLength = maxNumElems >>> 6;        if ((maxNumElems & 63) != 0) {            bitmapLength ++;        }        this.bitmapLength = bitmapLength;        bitmap = new long[bitmapLength];        // 下一个可用内存块对应的 bitmapIndex，初始为 0        nextAvail = 0;        // 将该 Subpage 采用头插法插入到对应规格的 smallSubpagePools 中        addToPool(head);    }}

final class PoolSubpage {    private final long[] bitmap;    private final int bitmapLength;}

final class PoolSubpage {    private void addToPool(PoolSubpage<T> head) {        prev = head;        next = head.next;        next.prev = this;        head.next = this;    }}

final class PoolChunk {
    boolean allocate(PooledByteBuf<T> buf, int reqCapacity, int sizeIdx, PoolThreadCache cache) {        // 待分配内存块        final long handle;        // 分配 Small 规格的内存块走 smallSubpagePools        if (sizeIdx <= arena.sizeClass.smallMaxSizeIdx) {            final PoolSubpage<T> nextSub;            // 获取对应规格 PoolSubpage 链表的头结点            PoolSubpage<T> head = arena.smallSubpagePools[sizeIdx];            head.lock();            try {                nextSub = head.next;                // 如果链表为空，那么 head.next 指向的是自己                if (nextSub != head) {                    // 始终从链表中第一个 PoolSubpage 开始分配                    handle = nextSub.allocate();                    // 将对应 Small 规格的内存块封装成 PooledByteBuffer 返回                    nextSub.chunk.initBufWithSubpage(buf, null, handle, reqCapacity, cache);                    return true;                }                // 链表为空，则到 PoolChunk 中重新申请一个 PoolSubpage                // 然后加入到 smallSubpagePools 对应规格的链表中                handle = allocateSubpage(sizeIdx, head);                if (handle < 0) {                    return false;                }                assert isSubpage(handle);            } finally {                head.unlock();            }        } else {           ...... 分配 Normal 规格内存块走 PoolChunk  ......        }        // 获取 PoolChunk 的 memory.duplicate() 视图缓存        ByteBuffer nioBuffer = cachedNioBuffers != null? cachedNioBuffers.pollLast() : null;        // nioBuffer 为 null 的话，后续访问 PooledByteBuffer 的时候通过 memory.duplicate() 创建        // 将 handle 封装成 PooledByteBuffer 返回        initBuf(buf, nioBuffer, handle, reqCapacity, cache);        return true;    }}

final class PoolSubpage {
    private int nextAvail;
    private int getNextAvail() {        // 初始为 0        int nextAvail = this.nextAvail;        if (nextAvail >= 0) {            this.nextAvail = -1;            return nextAvail;        }        // nextAvail 为 -1 ，表示此时没有刚被释放的内存块        // 那么就需要遍历 bitmap ， 找到第一个为 0 的内存块 bitmapIndex        return findNextAvail();    }}

    private int findNextAvail() {        // 遍历 bitmap , 在 bitmap 中查找第一个还未全部分配出去的内存块 bitmapIndex        for (int i = 0; i < bitmapLength; i ++) {            long bits = bitmap[i];            // ~bits = 0 表示这个 long 表示的 64 个内存块已经全部分配出去了            // ~bits != 0 表示这个 long 中还有未被分配出去的内存块            if (~bits != 0) {                // 找出 bits 中具体哪一位为 0 ，也就是说具体哪一个内存块未被分配                return findNextAvail0(i, bits);            }        }        // subPage 中无内存块可用        return -1;    }

    private int findNextAvail0(int i, long bits) {        // i 表示 bitmap 数组的 index,也就是第几个 long，注意 i 并不是 bitmapIndex        // i * 64        final int baseVal = i << 6;        // 从 bitmap[i] 中第一个 bit 开始遍历查找        for (int j = 0; j < 64; j ++) {            // 检查 bits 的第一个 bit 是否为 0             if ((bits & 1) == 0) {                // j 表示现在检查到 bits 中的第几个 bit                // baseVal + j 表示该内存块的 bitmapIndex                int val = baseVal | j;            }            // 最低位 bit 检查完之后，右移一位，开始检查下一个 bit 是否为 0            bits >>>= 1;        }        return -1;    }

final class PoolSubpage {
    long allocate() {        if (numAvail == 0 || !doNotDestroy) {            return -1;        }        // 获取 subPage 下一个可用内存块的 bitmapIdx        final int bitmapIdx = getNextAvail();        // -1 表示 subPage 中所有内存块都已经被分配出去了（没有空闲内存块）        if (bitmapIdx < 0) {            // subPage 全部分配完之后，就从 smallSubpagePools 中删除            removeFromPool();        }        // 第几个 long        int q = bitmapIdx >>> 6;        // long 中的第几个 bit        int r = bitmapIdx & 63;        // 内存块必须是空闲的        assert (bitmap[q] >>> r & 1) == 0;        // 设置内存块在 bitmap 中对应的 bit 位为 1 （已分配）        bitmap[q] |= 1L << r;
        if (-- numAvail == 0) {            // subPage 全部分配完之后，就从 smallSubpagePools 中删除            removeFromPool();        }        // 组装成 handle 结构返回        return toHandle(bitmapIdx);    }}

    private long toHandle(int bitmapIdx) {        // PoolSubpage 中包含的 page 个数        int pages = runSize >> pageShifts;        // 低 32 位保存 bitmapIdx        return (long) runOffset << RUN_OFFSET_SHIFT               | (long) pages << SIZE_SHIFT               | 1L << IS_USED_SHIFT               | 1L << IS_SUBPAGE_SHIFT               | bitmapIdx;    }

    static boolean isSubpage(long handle) {        return (handle >> IS_SUBPAGE_SHIFT & 1) == 1L;    }

final class PoolChunk {    /**     * manage all subpages in this chunk     */    private final PoolSubpage<T>[] subpages;}

    static int runOffset(long handle) {        return (int) (handle >> RUN_OFFSET_SHIFT);    }

subpage.free(head, bitmapIdx(handle))

final class PoolChunk {    void free(long handle, int normCapacity, ByteBuffer nioBuffer) {        // Small 规格内存块的释放        if (isSubpage(handle)) {            // 获取内存块所在 PoolSubpage 的 runOffset            int sIdx = runOffset(handle);            PoolSubpage<T> subpage = subpages[sIdx];            // 获取 PoolSubpage 所在 smallSubpagePools 对应规格链表头结点            PoolSubpage<T> head = subpage.chunk.arena.smallSubpagePools[subpage.headIndex];
            head.lock();            try {                assert subpage.doNotDestroy;                // 将内存块释放回 PoolSubpage 中                // true 表示 PoolSubpage 还是一个 Partial PoolSubpage（部分空闲） , 继续留在 smallSubpagePools 中                // false 表示 PoolSubpage 变成了一个 Empty PoolSubpage（全部空闲），从 smallSubpagePools 链表中移除                if (subpage.free(head, bitmapIdx(handle))) {                    // the subpage is still used, do not free it                    return;                }                // Empty PoolSubpage 从 PoolChunk subpages 数组中移除                subpages[sIdx] = null;            } finally {                head.unlock();            }        }
        ........ 释放 Normal 规格内存块或者 Empty PoolSubpage ......
        } finally {            runsAvailLock.unlock();        }    }}

 int q = bitmapIdx >>> 6;

int r = bitmapIdx & 63;  

bitmap[q] ^= 1L << r;

final class PoolSubpage {    private void setNextAvail(int bitmapIdx) {        nextAvail = bitmapIdx;    }}

final class PoolSubpage {
    boolean free(PoolSubpage<T> head, int bitmapIdx) {        // bitmap 中第几个元素        int q = bitmapIdx >>> 6;        // long 型整数的具体第几个 bit        int r = bitmapIdx & 63;                // 将内存块在 bitmap 中对应的 bit 设置为 0        bitmap[q] ^= 1L << r;        // 设置 nextAvail，下一次申请的时候优先分配刚刚被释放的内存块        setNextAvail(bitmapIdx);        // Full PoolSubpage 恰好变为 Partial PoolSubpage        if (numAvail ++ == 0) {            // 将这个 PoolSubpage 重新添加到  smallSubpagePools 中            addToPool(head);            // 确保 PoolSubpage 现在是一个 Partial PoolSubpage            // 如果 maxNumElems = 1，那么这里的  PoolSubpage 会立即变为一个 Empty PoolSubpage（全部空闲）            if (maxNumElems > 1) {                // 返回 true 表示 PoolSubpage 是一个 Partial PoolSubpage                // 需要保留在 smallSubpagePools 中                return true;            }        }        // numAvail = maxNumElems 说明 PoolSubpage 此时变为一个 Empty PoolSubpage（全部空闲）        if (numAvail != maxNumElems) {            // Partial PoolSubpage 继续停留在 smallSubpagePools            return true;        } else {            // 对于一个 Empty PoolSubpage 来说，Netty 需要将其从 smallSubpagePools 中删除，并释放 PoolSubpage 回 PoolChunk            // 如果该  PoolSubpage 是 smallSubpagePools 对应规格链表中的唯一元素，那么就让它继续停留            if (prev == next) {                // 始终保证 smallSubpagePools 对应规格的 PoolSubpage 链表中至少有一个 PoolSubpage                return true;            }            // 如果对应的 PoolSubpage 链表中还有多余的 PoolSubpage            // 那么就将这个 Empty PoolSubpage 释放掉            doNotDestroy = false;            // 将该 Empty PoolSubpage 从 smallSubpagePools 中删除            removeFromPool();            return false;        }    }}

final class PoolChunk {
    void initBuf(PooledByteBuf<T> buf, ByteBuffer nioBuffer, long handle, int reqCapacity,                 PoolThreadCache threadCache) {        if (isSubpage(handle)) {            // Small 规格的 handle 转换为 PooledByteBuf            initBufWithSubpage(buf, nioBuffer, handle, reqCapacity, threadCache);        } else {            // Normal 规格的 handle 转换为 PooledByteBuf            int maxLength = runSize(pageShifts, handle);            // PooledByteBuf 中的 offset 偏移为 runOffset(handle) << pageShifts            buf.init(this, nioBuffer, handle, runOffset(handle) << pageShifts,                    reqCapacity, maxLength, arena.parent.threadCache());        }    }}

    protected final int idx(int index) {        return offset + index;    }
    @Override    protected byte _getByte(int index) {        return memory.get(idx(index));    }
    @Override    protected void _setByte(int index, int value) {        memory.put(idx(index), (byte) value);    }

final class PoolChunk {    void initBufWithSubpage(PooledByteBuf<T> buf, ByteBuffer nioBuffer, long handle, int reqCapacity,                            PoolThreadCache threadCache) {        int runOffset = runOffset(handle);        int bitmapIdx = bitmapIdx(handle);        PoolSubpage<T> s = subpages[runOffset];        // PooledByteBuf 中的 offset 偏移        int offset = (runOffset << pageShifts) + bitmapIdx * s.elemSize;        buf.init(this, nioBuffer, handle, offset, reqCapacity, s.elemSize, threadCache);    }}

abstract class PooledByteBuf {    private void init0(PoolChunk<T> chunk, ByteBuffer nioBuffer,                       long handle, int offset, int length, int maxLength, PoolThreadCache cache) {
        // 该 PooledByteBuf 所属的 PoolChunk        this.chunk = chunk;        // PoolChunk 底层依赖的 ByteBuffer （4M）        memory = chunk.memory;        // PoolChunk  memory  的 duplicate 视图        // 对于 PooledByteBuf 的 read ,write 操作最终都会落在 tmpNioBuf 上        tmpNioBuf = nioBuffer;        // PooledByteBuf 背后的内存池 —— PooledByteBufAllocator        allocator = chunk.arena.parent;        // 所属的 PoolThreadCache （线程本地缓存）        this.cache = cache;        // PooledByteBuf 底层依赖的内存块 handle 结构        this.handle = handle;        // PooledByteBuf 相对于 PoolChunk 起始内存地址的偏移，以字节为单位        this.offset = offset;        // 用户本来请求的内存尺寸        this.length = length;        // 内存池实际分配的内存尺寸        this.maxLength = maxLength;    }}

final class PoolChunk {  private final Deque<ByteBuffer> cachedNioBuffers;}

final class PoolChunk {    boolean allocate(PooledByteBuf<T> buf, int reqCapacity, int sizeIdx, PoolThreadCache cache) {
            ..... 省略分配 handle 的逻辑 ......
        ByteBuffer nioBuffer = cachedNioBuffers != null? cachedNioBuffers.pollLast() : null;        initBuf(buf, nioBuffer, handle, reqCapacity, cache);        return true;    }}

abstract class PooledByteBuf {    @Override    protected final void deallocate() {        if (handle >= 0) {            final long handle = this.handle;            this.handle = -1;            memory = null;            // 释放 PooledByteBuf 背后的内存块回内存池中            chunk.arena.free(chunk, tmpNioBuf, handle, maxLength, cache);            tmpNioBuf = null;            chunk = null;            cache = null;            // 释放 PooledByteBuf 这个 Java 实例回对象池中            this.recyclerHandle.unguardedRecycle(this);        }    }}

final class PoolThreadCache {    // 与线程绑定的 PoolArena    final PoolArena<ByteBuffer> directArena;    // 本地缓存线程申请过的 Small 规格内存块    private final MemoryRegionCache<ByteBuffer>[] smallSubPageDirectCaches;    // 本地缓存线程申请过的 Normal 规格内存块    private final MemoryRegionCache<ByteBuffer>[] normalDirectCaches;}

    // numCaches 表示有多少种 Small 规格尺寸（39）    // cacheSize 表示每一种 Small 规格尺寸可以缓存多少个内存块（256）    private static <T> MemoryRegionCache<T>[] createSubPageCaches(            int cacheSize, int numCaches) {        if (cacheSize > 0 && numCaches > 0) {            // 为每一个 small 内存规格创建 MemoryRegionCache 本地缓存结构            // cacheIndex 就是对应的 small 内存规格的 sizeIndex                   MemoryRegionCache<T>[] cache = new MemoryRegionCache[numCaches];            for (int i = 0; i < cache.length; i++) {                // 初始化 smallSubPageDirectCaches 数组                cache[i] = new SubPageMemoryRegionCache<T>(cacheSize);            }            return cache;        } else {            return null;        }    }
    private static final class SubPageMemoryRegionCache<T> extends MemoryRegionCache<T> {        SubPageMemoryRegionCache(int size) {            super(size, SizeClass.Small);        }    }

    private abstract static class MemoryRegionCache<T> {        // queue 中缓存内存块的个数上限        private final int size;        // 用于缓存线程本地内存块的 MpscQueue        private final Queue<Entry<T>> queue;        // 内存块是 Small 规格还是 Normal 规格 ？        private final SizeClass sizeClass;        // 从该缓存中分配内存块的次数        private int allocations;
        MemoryRegionCache(int size, SizeClass sizeClass) {            // 表示每一个 MemoryRegionCache 中，queue 中可以缓存的内存块个数            // 每种 Small 规格尺寸默认可以缓存 256 个内存块            // 每种 Normal 规格尺寸默认可以缓存 64 个内存块            this.size = MathUtil.safeFindNextPositivePowerOfTwo(size);            queue = PlatformDependent.newFixedMpscQueue(this.size);            this.sizeClass = sizeClass;        }}

    // cacheSize 表示每一种 Normal 规格尺寸可以缓存多少个内存块（64）    // maxCachedBufferCapacity 表示可缓存的最大 Normal 规格尺寸（32K）    // maxCachedBufferCapacity 以下的 Normal 规格会缓存，超过 maxCachedBufferCapacity 的 Normal 规格则不会被缓存    // PoolArena 表示与线程绑定的内存池    private static <T> MemoryRegionCache<T>[] createNormalCaches(            int cacheSize, int maxCachedBufferCapacity, PoolArena<T> area) {
        if (cacheSize > 0 && maxCachedBufferCapacity > 0) {            // 最大可缓存的 Normal 规格            int max = Math.min(area.sizeClass.chunkSize, maxCachedBufferCapacity);            // 创建 normalDirectCaches            List<MemoryRegionCache<T>> cache = new ArrayList<MemoryRegionCache<T>>() ;            for (int idx = area.sizeClass.nSubpages; idx < area.sizeClass.nSizes &&                    area.sizeClass.sizeIdx2size(idx) <= max; idx++) {                // 为 maxCachedBufferCapacity 以下的 Normal 规格创建本地缓存 MemoryRegionCache                cache.add(new NormalMemoryRegionCache<T>(cacheSize));            }            // 返回 normalDirectCaches （转换成数组）            return cache.toArray(new MemoryRegionCache[0]);        } else {            return null;        }    }
    private static final class NormalMemoryRegionCache<T> extends MemoryRegionCache<T> {        NormalMemoryRegionCache(int size) {            super(size, SizeClass.Normal);        }    }