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的内存分配信息。
好了，今天就到这里了，希望对学习理解有帮助，大神看见勿喷，仅为自己的学习理解，能力有限，请多包涵。
