（*文章基于Netty4.1.22版本）
整体介绍
分析PoolChunk的时候，讲到大于等于8KB走Chunk，否则走PoolSubpage，为什么要这么做呢？假如我们需要分配1KB的内存，那么如果还是用Chunk来分配，那么由于Chunk是默认8KB，那么就有7KB的空间浪费了，无法分配，因为一个Chunk是一个整体，所以Netty在Chunk之下拆分了大小相等的内存段，即PoolSubpage，这样空间的利用就更合理了
源码分析
字段介绍
final class PoolSubpage<T> implements PoolSubpageMetric {
final PoolChunk<T> chunk;
// 即PoolChunk的id
private final int memoryMapIdx;
// page在Chunk叶子节点的相对位移，如果id为2048则runOffset为0,2049则为1，以此类推
private final int runOffset;
// Chunk的大小
private final int pageSize;
// 用来标记内存段分配情况的数组，原理类似Java的BitSet
private final long[] bitmap;
// 两个指针
PoolSubpage<T> prev;
PoolSubpage<T> next;
boolean doNotDestroy;
// 每个内存段的大小
int elemSize;
// 内存段的数量
private int maxNumElems;
private int bitmapLength;
private int nextAvail;
// 可用的内存段数量
private int numAvail;
}
基本介绍如上，其中需要详细分析的是这个bitmap数组，数组里每个元素是long类型，bitmap在初始化的时候会设置pageSize>>>10个元素，即8个元素
- 那么为什么是8？
在分配的时候，外部会先经过PoolArena(后续分析)，这时会处理请求的字节大小，保证其为2的N次方，且最小为16，那么8KB的情况下，最多会分割成512个内存段，一个long是64位，512/64=8，所以最多只需要8个long元素就可以分配所有段。
每个long元素有64位，每一位可以用来标志一个内存段的使用情况，由于是使用类似BitSet的结构，bitmap的结构图如下：
bitmap有8个long元素，每个long有64位，每一位都能标志一个内存的分配情况，共计8*64=512位。
初始化
// PoolArena中有个page的pool，head为里面的头结点
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]; // pageSize / 16 / 64
init(head, elemSize);
}
// 初始化每个段落的基本信息，例如每个内存段大小，内存段的数量，然后加入到Arena的PagePool的头结点中
void init(PoolSubpage<T> head, int elemSize) {
doNotDestroy = true;
this.elemSize = elemSize;
if (elemSize != 0) {
// 元素大小=可用数量=Chunk的pageSize / 每个元素的大小
maxNumElems = numAvail = pageSize / elemSize;
nextAvail = 0;
bitmapLength = maxNumElems >>> 6;
if ((maxNumElems & 63) != 0) {
bitmapLength ++;
}
for (int i = 0; i < bitmapLength; i ++) {
bitmap[i] = 0;
}
}
addToPool(head);// 加入到头结点后面
}
分配
在PoolChunk分配的时候，如果小于8KB会调用allocateSubpage，其中会初始化PoolSubpage并用其分配
private long allocateSubpage(int normCapacity) {
PoolSubpage<T> head = arena.findSubpagePoolHead(normCapacity);
synchronized (head) {//
// ....
final PoolSubpage<T>[] subpages = this.subpages;
final int pageSize = this.pageSize;
freeBytes -= pageSize;
// subpageIdx = 0 1 2 3 4 ....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();
}
}
long allocate() {
//....
// 找出一个可用的位置
final int bitmapIdx = getNextAvail();
int q = bitmapIdx >>> 6;// 图中的q
int r = bitmapIdx & 63;// 图中的r
assert (bitmap[q] >>> r & 1) == 0;
bitmap[q] |= 1L << r;
// 没分配一个位置，numAvail-1
if (-- numAvail == 0) {//当全部分配完毕，将该subpage从链表中移除
removeFromPool();
}
return toHandle(bitmapIdx);
}
private long toHandle(int bitmapIdx) {
return 0x4000000000000000L | (long) bitmapIdx << 32 | memoryMapIdx;
}
获取下一个可用的位置
private int getNextAvail() {
int nextAvail = this.nextAvail;
if (nextAvail >= 0) {
this.nextAvail = -1;
return nextAvail;
}
return findNextAvail()//核心在这里
}
private int findNextAvail() {
final long[] bitmap = this.bitmap;
final int bitmapLength = this.bitmapLength;
for (int i = 0; i < bitmapLength; i ++) {
long bits = bitmap[i];
if (~bits != 0) {// 该long元素上还有未分配的位置，当64位全为1的时候~bits才等于0
return findNextAvail0(i, bits);
}
}
return -1;
}
private int findNextAvail0(int i, long bits) {
final int maxNumElems = this.maxNumElems;
final int baseVal = i << 6;//0 64 128....
for (int j = 0; j < 64; j ++) {
if ((bits & 1) == 0) {//还有可用的位置，取得一个可以用的位置
int val = baseVal | j;
if (val < maxNumElems) {
return val;
} else {
break;
}
}
bits >>>= 1;
}
return -1;
}
getNextAvail会获取0~maxNumElems中可以用的位置
bitmap设值
bitmap[q] |= 1L << r;
这句代码怎么理解呢，其实就是如下的过程：
r=0：0000....0001 ->1
r=1：0000....0010 ->3
r=2：0000....0100 ->7
r=3：0000....1000 ->15
下一个r与上一个bitmap的值做或操作
返回page索引
当使用PoolChunk分配的时候，会返回一个id，即树中节点的值，代表该节点被分配，那么在使用PoolSubpage的时候也需要返回一个值代表page中某个节点被分配，通过上面的分析我们知道了，Page最多有512个节点，那么返回的值有0~511，那么如果就这样返回出去了，那么外部就无法知道到底是分配了Chunk还是Page，因为释放的时候，会传入这个唯一标志值，所以在这里调用了toHandle进行了一波骚操作，会让其变成一个64位的信息，然后释放的时候就可以知道该释放Chunk还是Page。
当然了，如果直到了用Chunk还是Page还是不够的，因为不知道用的是哪个Chunk的Page，所以在toHandle方法中还会看到对memoryMapIdx进行了计算
0x4000000000000000L | (long) bitmapIdx << 32 | memoryMapIdx;
左移32位转换成64位信息是为了判断是用Page还是用Chunk，和memoryMapIdx做位运算是为了判断在属于哪个Chunk
（这里要感谢闪电哥的热心解答，嘿嘿）
释放
// 如果返回true代表该PoolSubpage已经被使用
// 如果返回false代表该PoolSubpage已经没有使用了
boolean free(PoolSubpage<T> head, int bitmapIdx) {
if (elemSize == 0) {
return true;
}
int q = bitmapIdx >>> 6;
int r = bitmapIdx & 63;
assert (bitmap[q] >>> r & 1) != 0;
bitmap[q] ^= 1L << r;
// 释放的时候设置nextAvail为当前的bitmapIdx，下次getNextAvail的时候可以直接使用
setNextAvail(bitmapIdx);
if (numAvail ++ == 0) {
addToPool(head);// 加入到头结点后面
return true;
}
if (numAvail != maxNumElems) {
return true;
} else {//一个未用
if (prev == next) {// 如果只有head和当前节点，那么直接返回
return true;
}
// 没有使用了，那么可以把该节点从链表中移除
doNotDestroy = false;
removeFromPool();
return false;
}
}
