（*文章基于Netty4.1.22版本）
Netty内存管理这块比较复杂，断断续续看了一个多月了，总要有点输出，写几篇文章稍微分析总结一下
整体介绍
PoolChunk的结构是一颗平衡二叉树，如下：
注：左边代表的是节点的序号，右边的深度，例如512号节点深度为9，其数据结构为数组memoryMap和depthMap，初始化时相等
PoolChunk默认深度为11，一个节点默认为8KB，上图中，最下面有Subpage这个结构，这个是用来分配小于8KB的内存，数量和叶子节点数一样
举几个个例子来说明一下分配过程：
1.需要分配8KB的内存
在叶子节点寻找一个空的位置进行分配即可，此时节点的变化如下：
3个格子分别代表的意思是：深度，memoryMap[id]，depthMap[id]，在未分配前，3者是相等。
当一个节点分配之后，其memoryMap[id]=深度+1，变成右图左下角的状态，另外其父节点的memoryMap[id]=min(左右孩子memoryMap值)，以此类推，一直到根节点
2.需要分配16KB的内存
在第10层分配一个节点即可，因为其两个孩子节点分别为8KB
那么就有几种分配状态：
- memoryMap[id] == depthMap[id]：该节点以及子节点未被分配
- memoryMap[id] > depthMap[id]：该节点被分配 or 该节点下有一个节点被分配
- memoryMap[id] == 深度+1：该节点被分配 or 该节点下所有孩子节点全被分配
注意，第二种情况下，不能分配16KB的内存，因为其子节点被分配，所剩空间不足
源码实现
源码中有大量的位运算，可能看起来不太直观，举个例子算一下就清晰了
初始化
PoolChunk(PoolArena<T> arena, T memory, int pageSize, int maxOrder, int pageShifts, int chunkSize, int offset) {
// ....省略部分赋值
unusable = (byte) (maxOrder + 1);// unusable = 深度+1，即上面图中的12
maxSubpageAllocs = 1 << maxOrder;// Subpage数 2的maxOrder次方 即2048
memoryMap = new byte[maxSubpageAllocs << 1];// maxSubpageAllocs << 1 = 2的maxOrder+1次方，即4096
depthMap = new byte[memoryMap.length];
int memoryMapIndex = 1;
// 有maxOrder层，从上往下，从左往右赋值
for (int d = 0; d <= maxOrder; ++ d) {
int depth = 1 << d;// 2的d次方
for (int p = 0; p < depth; ++ p) {
// 每一层的深度都是d，赋值给memoryMap和depthMap，所以depthMap和memoryMap初始化时是相同的
memoryMap[memoryMapIndex] = (byte) d;
depthMap[memoryMapIndex] = (byte) d;
memoryMapIndex ++;
}
}
// 初始化subpage
subpages = newSubpageArray(maxSubpageAllocs);
}
分配
long allocate(int normCapacity) {
if ((normCapacity & subpageOverflowMask) != 0) { // >= pageSize
return allocateRun(normCapacity);
} else {
return allocateSubpage(normCapacity);
}
}
分配方法有两个分支流程，一个是大于8KB的，走poolChunk，小于8KB的，走Subpage
allocateRun
private long allocateRun(int normCapacity) {
// 根据需要的空间，计算应该在哪一层分配
int d = maxOrder - (log2(normCapacity) - pageShifts);
int id = allocateNode(d);//从该深度的节点中，找出一个空闲的节点
if (id < 0) {
return id;
}
freeBytes -= runLength(id);//计算该节点所占内存并减去，freeBytes为剩余空闲内存
return id;
}
由于一个Chunk为8KB，即8192，即2的13次方，所以pageShitfs为13。
至于 maxOrder - (log2(normCapacity) - pageShifts); 怎么理解呢，由于normCapacity在外层传入的时候就已经做过纠正，其值为2的N次方，那么假设normCapacity为8KB，log2(normCapacity)为13，减去pageShifts，最后算出来的就是maxOrder层，以此类推
allocateNode
private int allocateNode(int d) {
int id = 1;
int initial = - (1 << d); // has last d bits = 0 and rest all = 1
byte val = value(id);// memoryMap[id]
if (val > d) { // 一开始说的第二种分配状态
return -1;
}
while (val < d || (id & initial) == 0) { // id & initial == 1 << d for all ids at depth d, for < d it is 0
id <<= 1;// 2 4 6 8 .... 512 1024 2048，即在树中最左边的那条路径
val = value(id);
if (val > d) {// 即memoryMap[id] > depthMap[id]：该节点被分配 or 该节点下有一个节点被分配
id ^= 1;// 兄弟节点
val = value(id);
}
}
byte value = value(id);
assert value == d && (id & initial) == 1 << d : String.format("val = %d, id & initial = %d, d = %d",
value, id & initial, d);
setValue(id, unusable); // 将该节点的memoryMap设置为深度+1，表示分配
updateParentsAlloc(id);// 将父节点设置为其孩子节点memoryMap最小的那个值
return id;
}
大概的流程就是：
- 先从最左边的叶子节点匹配，如果该节点为分配，则分配该节点
- 如果该节点已分配，那么判断兄弟节点是否分配，如果未分配，则分配该节点
- 如果兄弟节点已经分配，那么从父节点的兄弟节点的孩子节点继续该过程
总的就是在一层中从左往右寻找匹配节点，其中兄弟节点的获取是id^1，刚好就是兄弟节点的值
释放
void free(long handle) {
int memoryMapIdx = memoryMapIdx(handle);// 将long类型的转换成int，即保留低位信息
int bitmapIdx = bitmapIdx(handle);//id >>> Integer.SIZE，右移32位，高位补0
if (bitmapIdx != 0) { // 如果是Chunk分配的，右移后，bitmapIdx会变成0，具体原因要看下Page的分析
//获取对应的Page
PoolSubpage<T> subpage = subpages[subpageIdx(memoryMapIdx)];
assert subpage != null && subpage.doNotDestroy;
PoolSubpage<T> head = arena.findSubpagePoolHead(subpage.elemSize);
synchronized (head) {
//调用Page的释放方法
if (subpage.free(head, bitmapIdx & 0x3FFFFFFF)) {
return;
}
}
}
freeBytes += runLength(memoryMapIdx);
// 和分配是逆过程
setValue(memoryMapIdx, depth(memoryMapIdx));
updateParentsFree(memoryMapIdx);
}
