概要
在Netty中, PoolArena将内存分为很多PoolChunk进行管理. 通过多个PoolChunkList根据PoolChunk的使用率进行分组保存，并将动态的移动至对应的PoolChunkList中
在PoolArena中根据使用率分如下几组PoolChunkList
private final PoolChunkList<T> q050; //存储内存利用率50-100%的PoolChunk
private final PoolChunkList<T> q025; //存储内存利用率25-75%的PoolChunk
private final PoolChunkList<T> q000; //存储内存利用率1-50%的PoolChunk
private final PoolChunkList<T> qInit; //存储内存利用率0-25%的PoolChunk
private final PoolChunkList<T> q075; //存储内存利用率75-100%的PoolChunk
private final PoolChunkList<T> q100; //存储内存利用率100%的PoolChunk
q100 = new PoolChunkList<T>(null, 100, Integer.MAX_VALUE, chunkSize);
q075 = new PoolChunkList<T>(q100, 75, 100, chunkSize);
q050 = new PoolChunkList<T>(q075, 50, 100, chunkSize);
q025 = new PoolChunkList<T>(q050, 25, 75, chunkSize);
q000 = new PoolChunkList<T>(q025, 1, 50, chunkSize);
qInit = new PoolChunkList<T>(q000, Integer.MIN_VALUE, 25, chunkSize);
q100.prevList(q075);
q075.prevList(q050);
q050.prevList(q025);
q025.prevList(q000);
q000.prevList(null);
qInit.prevList(qInit);
img
PoolChunkList类主要属性如下所示：
// 下一个ChunkList
private final PoolChunkList<T> nextList;
// 最小内存使用率
private final int minUsage;
// 最大内存使用率
private final int maxUsage;
private final int maxCapacity;
// 头节点
private PoolChunk<T> head;
// 上一个ChunkList
private PoolChunkList<T> prevList;
img
构造方法
PoolChunkList(PoolChunkList<T> nextList, int minUsage, int maxUsage, int chunkSize) {
assert minUsage <= maxUsage;
this.nextList = nextList;
this.minUsage = minUsage;
this.maxUsage = maxUsage;
// 该list所能分配的最大容量
maxCapacity = calculateMaxCapacity(minUsage, chunkSize);
}
private static int calculateMaxCapacity(int minUsage, int chunkSize) {
minUsage = minUsage0(minUsage);
if (minUsage == 100) {
return 0;
}
// 计算一个chunk在除去最小的使用率的情况下所能分配的最大空间
// Q25的maxCapacity=chunkSize*75%
return (int) (chunkSize * (100L - minUsage) / 100L);
}
添加
void add(PoolChunk<T> chunk) {
// 看当前chunk的使用率是否超过了最大值, 加到下一个list
if (chunk.usage() >= maxUsage) {
nextList.add(chunk);
return;
}
add0(chunk);
}
void add0(PoolChunk<T> chunk) {
// 在chunk中保存所属的chunlist
chunk.parent = this;
// 如果还没有head, chunk来
if (head == null) {
head = chunk;
chunk.prev = null;
chunk.next = null;
} else {
// 将这个chunk加到list里面作为新的head
chunk.prev = null;
chunk.next = head;
head.prev = chunk;
head = chunk;
}
}
删除
private void remove(PoolChunk<T> cur) {
if (cur == head) {
// 让下一个接替head
head = cur.next;
if (head != null) {
head.prev = null;
}
} else {
// 将cur前后解绑
PoolChunk<T> next = cur.next;
cur.prev.next = next;
if (next != null) {
next.prev = cur.prev;
}
}
}
分配
boolean allocate(PooledByteBuf<T> buf, int reqCapacity, int normCapacity) {
// 如果没有head或超过最大容量,那么返回false,表示分配失败
if (head == null || normCapacity > maxCapacity) {
return false;
}
// 遍历chunklist
for (PoolChunk<T> cur = head;;) {
// 去chunk中申请空间
long handle = cur.allocate(normCapacity);
// 如果handle<0, 说明申请失败, 继续滚动到下一个chunk循环
if (handle < 0) {
cur = cur.next;
if (cur == null) {
return false;
}
} else {
// 如果申请成功, 那么将内存空间与ByteBuf进行绑定
cur.initBuf(buf, handle, reqCapacity);
// 接着计算当前chunk的使用率,如果超过最大阈值,那么从当前list中删除,并移动到下个list
// 也就是升舱处理
if (cur.usage() >= maxUsage) {
remove(cur);
nextList.add(cur);
}
return true;
}
}
}
释放
boolean free(PoolChunk<T> chunk, long handle) {
// 释放该chunk对应的handle持有的内存空间
chunk.free(handle);
// 如果小于最下,那么同理需要降级处理
if (chunk.usage() < minUsage) {
remove(chunk);
// Move the PoolChunk down the PoolChunkList linked-list.
return move0(chunk);
}
return true;
}
移动
private boolean move0(PoolChunk<T> chunk) {
if (prevList == null) {
assert chunk.usage() == 0;
return false;
}
return prevList.move(chunk);
}
private boolean move(PoolChunk<T> chunk) {
// 接着move0的上下文,这里已经到了prevlist, 判断是否满足该list的使用率条件
assert chunk.usage() < maxUsage;
// 如果还是低于该区的最小,那么继续降级
if (chunk.usage() < minUsage) {
return move0(chunk);
}
// 否则add到该list
add0(chunk);
return true;
}
