在PoolArena中由PoolSubpage双向链表分配内存小于PageSize（Netty默认8KB）的请求。在JEMalloc分配算法一文中介绍过，其中的结构如下图：
而
Subpage又是由
PoolChunk中的一个Page依照第一次分配请求的大小均等切分而成。可推知，小于PageSize的分配请求执行过程如下：
- 首次请求Arena分配，Arena中的双向链表为空，不能分配；传递给Chunk分配，Chunk找到一个空闲的Page，然后均等切分并加入到Arena链表中，最后分配满足要求的大小。
- 之后请求分配同样大小的内存，则直接在Arena中的
PoolSubpage双向链表进行分配；如果链表中的节点都没有空间分配，则重复1步骤。
Netty使用一个long整型表示在PoolSubpage中分配的结果，其中低32位表示PoolSubpage所属的Page的标号，高32位表示均等切分小块的块号。实际中，Netty使用位图来表示均等小块的分配信息，其中位图有用long数组表示，所以对于高32位，其中的低6位用来表示64位即一个long的分配信息，其余位用来表示long数组的索引。可参见下图示意：
|<-- 24 -->| <-- 6 --> | <-- 32 --> |
| long数组偏移 | long的二进制位偏移| 所属Chunk标号 |
明白了这些，开始分析源码实现。首先看成员变量：
private final int memoryMapIdx; // 所属Page的标号
private final int runOffset; // 在整个Chunk的偏移字节数
private final int pageSize; // 页大小
private final long[] bitmap; // 均等小块的分配信息
boolean doNotDestroy; // 是否需要释放整个Page
int elemSize; // 均等切分的大小
private int maxNumElems; // 最多可以切分的小块数
private int bitmapLength; // 位图信息的长度,long的个数
private int nextAvail; // 下一个可分配的小块位置信息
private int numAvail; // 可用的小块数
final PoolChunk chunk; // 所属的Chunk
PoolSubpage next; // arena双向链表的后继节点
PoolSubpage prev; // arena双向链表的前驱节点
构造方法有两个，其中一个用于构造双向链表的头节点Head，这是一个特殊节点，不进行分配，不列出代码。重点关注普通节点构造方法：
PoolSubpage(PoolSubpage head, PoolChunk chunk,
int memoryMapIdx, int runOffset, int pageSize, int elemSize) {
this.chunk = chunk;
this.memoryMapIdx = memoryMapIdx;
this.runOffset = runOffset;
this.pageSize = pageSize;
// 此处使用最大值，最小分配16B所需的long个数
bitmap = new long[pageSize >>> 10]; // pageSize / 16 / 64
init(head, elemSize);
}
void init(PoolSubpage head, int elemSize) {
doNotDestroy = true;
this.elemSize = elemSize;
if (elemSize != 0) {
maxNumElems = numAvail = pageSize / elemSize;
nextAvail = 0;
bitmapLength = maxNumElems >>> 6; // /64 表示long的个数
if ((maxNumElems & 63) != 0) {
bitmapLength ++; // subpage不是64倍，多需要一个long
}
for (int i = 0; i < bitmapLength; i ++) {
bitmap[i] = 0;
}
}
addToPool(head);
}
需要注意的是：Netty使用了多个long整数的位数表示位图信息，这部分代码主要是在初始化位图结构。bitmap的最大长度为pageSize >>> 10表示最小分配16(1>>>4)B所需的long(1>>>6)个数，此处不使用pageSize/elemSize/64是因为考虑到复用。当一个PoolSubpage以32B均等切分，然后释放返回给Chunk，当Chunk再次被分配时，比如16B，此时只需调用init()方法即可而不再需要初始其他数据。
最后的addToPool()方法将该PoolSubpage加入到Arena的双向链表中，代码如下：
private void addToPool(PoolSubpage head) {
assert prev == null && next == null;
prev = head;
next = head.next;
next.prev = this;
head.next = this;
}
这是经典的双向链表操作，只需注意每次新加入的节点都在Head节点之后。从链表中删除的操作是该操作的逆操作，实现代码如下：
private void removeFromPool() {
assert prev != null && next != null;
prev.next = next;
next.prev = prev;
next = null;
prev = null;
}
接着分析关键的分配过程，代码如下：
long allocate() {
if (elemSize == 0) {
return toHandle(0);
}
// 1.没有可分配均等小块 2.需要销毁(arena池中有其他可分配subpage)
if (numAvail == 0 || !doNotDestroy) {
return -1;
}
final int bitmapIdx = getNextAvail();
int q = bitmapIdx >>> 6; // 高24为表示long数组索引
int r = bitmapIdx & 63; // 低6位表示在long中实际分配的二进制位
assert (bitmap[q] >>> r & 1) == 0;
bitmap[q] |= 1L << r; // 将该信息加入到分配信息中
if (-- numAvail == 0) {
removeFromPool(); // 没有可分配的均等块则从arena双向链表删除
}
return toHandle(bitmapIdx); // 转换为64位分配信息
}
private long toHandle(int bitmapIdx) {
return 0x4000000000000000L | (long) bitmapIdx << 32 | memoryMapIdx;
}
其中较难理解的位运算部分，转化为bitSet则只是bitSet.set(i, true)，Netty为了效率使用了long数组表示位图信息，所以稍显复杂。接着分析其中的getNextAvail()方法，该方法用来寻找在位图中可用的下一个位，代码如下：
private int getNextAvail() {
int nextAvail = this.nextAvail;
if (nextAvail >= 0) {
// 此时的nextAvail是上一个释放的均等小块
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) {
// 还有可用的均等小块
return findNextAvail0(i, bits);
}
}
return -1;
}
private int findNextAvail0(int i, long bits) {
final int maxNumElems = this.maxNumElems;
final int baseVal = i << 6;
// long从低位开始表示分配信息，最低位表示第1块分配
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;
}
寻找可用分配块，即按序寻找long数组中，二进制为0的位即表示可用的小块序列。对应的释放方法free()代码如下：
boolean free(PoolSubpage head, int bitmapIdx) {
if (elemSize == 0) {
return true;
}
int q = bitmapIdx >>> 6; // long数组索引
int r = bitmapIdx & 63; // long的二进制位偏移
assert (bitmap[q] >>> r & 1) != 0;
bitmap[q] ^= 1L << r; // 异或运算清除改位
setNextAvail(bitmapIdx); // 该位置的小块可用于下次分配
if (numAvail ++ == 0) {
// 该page已分配了至少一个subpage，加入到arena双向链表
addToPool(head);
return true;
}
if (numAvail != maxNumElems) {
return true;
} else {
if (prev == next) {
// prev==next==head 只有头结点和该节点
return true;
}
// 从双向链表中释放，因为双向链表中至少有一个可用节点
doNotDestroy = false;
removeFromPool();
return false;
}
}
需要注意的是该方法的返回值，返回true表示该subpage在使用中，返回false表示该subPage不再由chunk使用可以释放。
至此，PoolSubpage分析完毕。
相关链接：
- JEMalloc分配算法
- PoolArena
- PoolChunk
- PoolChunkList
- PooThreadCache