PoolChunk的allocateSubpage

这个比上篇那个要再进一步划分内存，这个是小于页大小的分配方式。

    private long allocateSubpage(int normCapacity) {
    		//获取子页数组的头结点，可以是ting数组也可以是small数组的
            PoolSubpage<T> head = arena.findSubpagePoolHead(normCapacity);
            int d = maxOrder; // 11
            synchronized (head) {//修改数据要同步
                int id = allocateNode(d);//找到能分配的内存映射索引
                if (id < 0) {
                    return id;//没找到
                }
    
                final PoolSubpage<T>[] subpages = this.subpages;//满二叉树的叶子节点数组
                final int pageSize = this.pageSize;//8k
                //减少一页大小的可用字节
                freeBytes -= pageSize;
                //获取子页数组索引，其实跟取模一样 0-2047
                int subpageIdx = subpageIdx(id);
                PoolSubpage<T> subpage = subpages[subpageIdx];//获取子页，第一次是空的
                if (subpage == null) {//第一次是空
                    subpage = new PoolSubpage<T>(head, this, id, runOffset(id), pageSize, normCapacity);
                    subpages[subpageIdx] = subpage;//添加进子页数组
                } else {
                    subpage.init(head, normCapacity);//重新初始化
                }
                return subpage.allocate();
            }
        }

PoolArena的findSubpagePoolHead

根据传进来的规范后的申请容量，找出PoolArena里的tinySubpagePools和smallSubpagePools数组里的匹配容量的PoolSubpage，其实是PoolSubpage链表的头结点head。

     PoolSubpage<T> findSubpagePoolHead(int elemSize) {
            int tableIdx;
            PoolSubpage<T>[] table;
            if (isTiny(elemSize)) { // < 512
                tableIdx = elemSize >>> 4;//获取索引
                table = tinySubpagePools;//获取子页数组
            } else {
                tableIdx = 0;
                elemSize >>>= 10;
                while (elemSize != 0) {//[512-pageSize) 尺寸和索引对应: 512->0 1024->1 2048->2 4096->3 刚是smallSubpagePoolsde的全部索引
                    elemSize >>>= 1;
                    tableIdx ++;
                }
                table = smallSubpagePools;
            }
    
            return table[tableIdx];
        }

PoolChunk的subpageIdx

获取页索引位运算其实跟取模结果一样，memoryMapIdx对maxSubpageAllocs(2048)求余数，因为memoryMapIdx在这里的范围是[2048-4095]，刚好对应余数是[0-2047]。

        private int subpageIdx(int memoryMapIdx) {
            return memoryMapIdx ^ maxSubpageAllocs; // remove highest set bit, to get offset
        }

runOffset

获得id节点对应的内存在块chunk中的偏移量，或者说起始地址。
depth和runLength在上一篇中已经讲过，这里主要是先计算偏移位数shift ，然后计算节点可分配内存大小runLength，偏移量就是偏移大小x节点大小。 int shift = id ^ 1 << depth(id);这里先算1 << depth(id)，找出某一深度的第一个内存映射索引，然后和id做异或，即是求出id对于这个索引的偏移位数。比如id=1025，1 << depth(id)=1024,1024^1025=1。即shift =1，同理id=1024,shift =0,id=1026,shift =2，以此类推。

    //计算内存偏移 即内存映射索引id对应的节点在块chunk中的偏移量 范围是[0 - chunkSize)，比如2048是0 x 8k=0 2049是1 x 8k=8k 1024是0 x 16k=0 1025是1 x 16k=16k
        private int runOffset(int id) {
            // 其实每一个节点的偏移位置就是他的左节点的偏移，叶子节点就是自身的偏移量
            int shift = id ^ 1 << depth(id);//节点的偏移位数 比如2048是0 2049是1 2050是2 ..4095是2047 也就是某个深度中从左到右的编号，从0开始。
            return shift * runLength(id);//偏移量=偏移位数x可分配内存大小
        }

PoolSubpage构造函数

PoolSubpage其实不会实际分配内存，只是做了分配内存的记录，记录一个页中哪些分配完了，哪些可以分配 ，实际的内存分配是在PoolChunk的memory属性中，前面讲过如果是申请堆内存，memory就是数组，否则如果申请直接内存，memory就是直接缓冲区。PoolSubpage在页空间分配满之后就会被删除释放。

        PoolSubpage(PoolSubpage<T> head, PoolChunk<T> chunk, int memoryMapIdx, int runOffset, int pageSize, int elemSize) {
            this.chunk = chunk;//所在块
            this.memoryMapIdx = memoryMapIdx;//内存映射索引
            this.runOffset = runOffset;//块内偏移
            this.pageSize = pageSize;//页大小
            bitmap = new long[pageSize >>> 10]; //最多需要多少个long类型的位图来描述一页分割成16B的所有内存的状态
            init(head, elemSize);
        }

bitmap = new long[pageSize >>> 10]; 这里解释下：这里的10，其实是4+6,4是表示16是2的4次方，6表示64是2的6次方，所以加起来是10，即用页大小8k除以16除以64，这里的意思就是以最小的尺寸16B来计算，一页能分几个16B大小的内存，然后用位图表示这个内存是否被用需要1位，如果用long类型的位图就是64位，所以除以64，就知道需要多少个64位的位图来表示这些16B的内存的状态。默认页大小8k，算出来需要8个这样的位图，所以位图数组长度是8。

一些主要属性

老规矩，先看一些主要的属性，后面就用到了。

        final PoolChunk<T> chunk;
        private final int memoryMapIdx;//内存映射索引
        private final int runOffset;//chunk中的偏移
        private final int pageSize;//页大小
        private final long[] bitmap;//64位的位图数组，描述某一尺寸内存的状态 每一位都可以表示是该内存否可用了 1表示不可用 0表示可用
    
        PoolSubpage<T> prev;//前驱
        PoolSubpage<T> next;//后继
    
        boolean doNotDestroy;//是否销毁
        int elemSize;//分割的内存尺寸大小
        private int maxNumElems;//一页存能存多少个尺寸都为elemSize的内存，即即最大可分配的内存数
        private int bitmapLength;//实际用到的位图数
        private int nextAvail;//下一个可用的位图索引
        private int numAvail;//可用内存的个数

init

进行一些属性的初始化，并将自身添加到头节点的后面。

    void init(PoolSubpage<T> head, int elemSize) {
            doNotDestroy = true;
            this.elemSize = elemSize;
            if (elemSize != 0) {
                maxNumElems = numAvail = pageSize / elemSize;//获取能分割成多少elemSize大小的内存
                nextAvail = 0;
                bitmapLength = maxNumElems >>> 6;//实际需要用的到的long类型的位图的个数，每个位图有64位，取整
                if ((maxNumElems & 63) != 0) {//有余数就多一个
                    bitmapLength ++;
                }
                //实际用到的位图数
                for (int i = 0; i < bitmapLength; i ++) {
                    bitmap[i] = 0;//初始化位图
                }
            }
            addToPool(head);
        }

addToPool

将当前子页加到head的后面，是个 双向循环链表 。

        private void addToPool(PoolSubpage<T> head) {
            assert prev == null && next == null;
            prev = head;
            next = head.next;
            next.prev = this;
            head.next = this;
        }

我画个示意图吧，一开始就只有head是这样的：

加一个之后：

后续如果有相同尺寸的请求，都会在这个子页里分配，直到子页满了后，会链表中删除。

可见pred和next都可以循环起来。

添加到chunk子页数组里

subpages[subpageIdx] = subpage子页创建后就被添加到了子页数组里，这里还有另外一个结构关系，就是PoolArena里的tinySubpagePools和smallSubpagePools与PoolChunk的subpages的关系，因为head是tinySubpagePools和smallSubpagePools元素，后续添加的PoolSubpage都会添加进head形成的双向循环链表中。用图来表示的话应该是这样，注意 这里的双向连线是双向循环链表，避免太乱所以这样表示 ：

后面就是讲subpage.allocate()子页的分配逻辑了，其实也就是一些分配记录，会降到位图的使用，这个还是挺关键的，位图在做记录信息的时候还是很有用的，占用空间又小，位运算速度又快。比如这个子页就用了64B的位图就可以记录8kB的内存分配信息。

好了，今天就到这里了，希望对学习理解有帮助，大神看见勿喷，仅为自己的学习理解，能力有限，请多包涵。

阅读全文

吃透 Netty 源码

吃透Netty源码系列二十二之池化内存分配三