if (id < 0) {
return id;
}
final PoolSubpage[] subpages = this.subpages;
final int pageSize = this.pageSize;
freeBytes -= pageSize;
int subpageIdx = subpageIdx(id); // @2
PoolSubpage subpage = subpages[subpageIdx];
if (subpage == null) {
subpage = new PoolSubpage(this, id, runOffset(id), pageSize, normCapacity); // 代码@3
subpages[subpageIdx] = subpage;
} else { //@4
subpage.init(normCapacity);
}
return subpage.allocate(); //代码@5
}
首先讲解一下整体分配思路，先根据PoolChunk内部维护的各个PoolChunk的占用情况，返回一个可以PoolChunk的id,这里的id就是memoryMap数组的下标。然后从PoolChunk维护的PoolSubpage数组对象中获取一个与之对应的PoolSubpage,如果为空，先创建一个PoolSubpage。然后再在PoolSubpage中分配内存。如果已经存在PoolSubpage,则直接分配。
代码@1：首先，我们需要从meomryMap中寻找一个可供分配的PoolSubpage。memoryMap就是记录整个PoolSubpage的占用情况。
代码@2：根据我们现在掌握的知识应该知道,memoryMap[ 2的maxOrder]存放的是第一个PoolSubpage,memoryMap[ 2的 (maxOrder+1)的幂再减去1]存放的是最后一个PoolSubpage,所以接下来我们需要将id转换为实际的PoolSubpage。从上面的讲解，其实 id 与 2的maxOrder的偏移，，比如基数2048对应0,2049对应1，基数是2048，根据id求数组中的下标应该清楚了吧，给出如下三个算法实现，请看下午的关于subpageIdx方法的详解。
代码@3：如果id对应的PoolSubpage没有被初始化，则新建一个PoolSubpage。在内存分配前置篇的时候特意讲解了PoolSubpage几个关键属性，当然包括这里的runOffset;在这里再重复一遍：在整个Netty内存管理中，其实真正持有内存的类是PoolChunk, 如果是直接内存，就是 java.nio.ByteBuffer memory;如果是堆内存的话，就是byte[] memory,我们以堆内存来讲解，比较直观，一个PoolChunk一旦创建，就会分配内存 byte[] memory = new byte[chunkSize]；然后PoolChunk由一个一个的PoolSubpage组成，也就是PoolSubpage[] subpages;那们我们如果保存 memoryMap[id]位置代表的PoolSubPage的内存呢？使用一个偏移量，相对于PoolChunk的byte[] meomry的偏移量。那怎么计算呢？先得出id所在平衡二叉树的深度，就能得到该层有多个节点，所谓的偏移量，就是针对同级的。当然，真正的偏移量主要还是针对PoolSubpage，整个Netty的内存管理，真正涉及到内存的只有PoolChunk,PoolSubpage维护一个偏移量，其实就是一个指针，表示PoolChunk的T memory的（从runOffset 至 (runOffset+pageSize）被这个PoolSubpage占用。
代码@5：PoolSubpage 的具体分配方法。
1.3.1.1 关于代码@1PoolChunk allocateSubpage 的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);
if (val > d) { // unusable
return -1;
}
while (val < d || (id & initial) == 0) { // id & initial == 1 << d for all ids at depth d, for < d it is 0 //@1
id <<= 1; //@2
val = value(id); //@3
if (val > d) { //@4
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); // mark as unusable //@5
updateParentsAlloc(id); //@6
return id;
}
private byte value(int id) {
return memoryMap[id];
}
这里再重复一次PoolChunk里面维护一颗平衡二叉树来映射PoolChunk每个PoolSubpage的是否已经被分配的情况，平衡二叉树的深度为maxOrder,也就是平衡二叉数的所有叶子节点代表所有的PoolSubpage，而整棵二叉树从根到下，从左到右被映射为一个数组memoryMap，memoryMap长度为( 2的 (maxOrder=1)),memoryMap[0]处不存放任何元素，从 id=1到 2的(maxOrder-1)幂-1,举个更直观的例子，比如maxOrder为10，则memoryMap[]的长度为2048,memoryMap[1] 存放平衡二叉树的根节点，memory[2],memory[3]存放深度为1的节点，依次类推，memoryMap[2047]存放最后一个叶子节点。具体的算法是从根节点(dept=0)开始，一直向下找，直到到达层为d。找合适的节点。
代码@2：找到id的左子树（左节点）。
代码@3：获取该id所在二叉树的深度。
代码@4：val > d 表示已经被占用，需要找id的兄弟，也就是右节点，在平衡二叉树，已知左节点，求右节点的下标，使用id^1即可，然后看右节点是否被占用，如果没有，直接返回。理解这个算法，要知道，如果memoryMap[id]不可用，则不会继续去查找其子节点，也就是说，如果memoryMap[id]可用，就代表了至少有一个节点是没有被占用的。如果全被占用,id的值会为 2的(maxOrder+1)的幂，再减去1，如果按照上面的例子，id=2047。
代码@5：将memoryMap[id]=unusable,(maxOrder+1)，代表PoolSubpage已经被占用。
代码@6：递归更新父节点的占用情况，这里有个哲学，memoryMap[id]中存的值，代表可以至少可以分配的深度数，比如memoryMap[8] = 2,则表示id为8的节点可以胜任分配深度>=2的内存大小，我们知道，深度越大，节点代表的内存就越小。比如id=3的节点，最小可以分配的深度为2，那他的子节点id为(6,7)能分配的最小深度为3，那比如id=6的节点已被分配，那它的直接父节点id=3，此时就不能再分配深度为2的内存了，因为已经被占用了一半，只能分配深度为3。updateParentsAlloc方法就是按照上述思路实现的，具体情况分析如下：
private void updateParentsAlloc(int id) {
while (id > 1) {// @1
int parentId = id >>> 1; // @2
byte val1 = value(id); //@3
byte val2 = value(id ^ 1); //@4
byte val = val1 < val2 ? val1 : val2; //@5
setValue(parentId, val);
id = parentId;
}
}
代码@1：循环调用，知道根节点。
代码@2：找到父节点。
代码@3，@4：得到parentId两个子节点当前可分配的深度值
代码@5：父节点可分配的深度值为两个子节点可分配的深度值的最小值。
1.3.1.2 PoolChunk的allocateSubpage代码@2 的 subpageIdx方法：
private int subpageIdx(int memoryMapIdx) {
return memoryMapIdx ^ maxSubpageAllocs; // remove highest set bit, to get offset
//我们一般简单的实现：
//return memoryMapIdx - maxSubpageAllocs;
//或 return memoryMapIdx & ( ~( (1 << maxOrder) -1) );
}
1.3.1.3 PoolChunk的allocateSubpage代码@5 poolSubpage.allocate方法详解：
/**
- Returns the bitmap index of the subpage allocation.
*/
long allocate() {
if (elemSize == 0) {
return toHandle(0);
}
if (numAvail == 0 || !doNotDestroy) { //@1
return -1;
}
final int bitmapIdx = getNextAvail(); //@2
int q = bitmapIdx >>> 6; //@3
int r = bitmapIdx & 63; //@4
assert (bitmap[q] >>> r & 1) == 0;
bitmap[q] |= 1L << r; //@5
if (-- numAvail == 0) {
removeFromPool(); //@6
}
return toHandle(bitmapIdx); //@7
}
代码@1：如果可用内存块小于0，则直接返回-1。
代码@2：从bitmap中，获取下一个可用的内存区域，PoolSubpage由大小相等的内存区域组成，总共maxNumElems个，每个区域大小为elemSize。如果没有可用的区域，返回-1,否则返回0-(maxNumElms)之间的一个值。
代码@3：q表示在bitmap中的下标。
代码@4：r表示 bitmapInx % 64 的余数。
代码@5：就是要将即将返回的PoolSubpag所代表的位设置为1, 1L<<<r,然后与bimap[q] | 1L<<r即可实现这样的逻辑。
代码@6：如果该PoolSubpage所有内存都被分配后，从PoolSubpage链表中移除，这是在哪个链表中呢？是PoolChunk的链表？不是，因为PoolChunk只维护一个所有的PoolSubpage数组，是移除PoolArena的PoolSubpage链表，从这里也可以看出PoolArena维护的tinyPoolSubpages[]和smallPoolSubpages[]中的PoolSubpage都是未全部用完的PoolSubpage。
代码@7：返回一个long类型的变量，该变量的后32位保存中该PoolSubpage在PoolChunk的memoryMap中的下标id,高32位保存bitmapIdx。
关于PoolSubpage allocate 代码@2详解：getNextAvail方法：
private int getNextAvail() {
int nextAvail = this.nextAvail;
if (nextAvail >= 0) { //@1
this.nextAvail = -1;
return nextAvail;
}
return findNextAvail();
}
如果是第一次分配，直接返回0，即可，因为下一个可用的就是0。
如果不是第一次分配，然后需要从bitmap中获取一个可用的PoolSubpage。进入findNextAvail()方法。
private int findNextAvail() {
final long[] bitmap = this.bitmap;
final int bitmapLength = this.bitmapLength;
for (int i = 0; i < bitmapLength; i ++) { //@2
long bits = bitmap[i];
if (~bits != 0) { //@3
return findNextAvail0(i, bits); //@4
}
}
return -1;
}
代码@2：遍历bitmap,根据当前的elmSize可以得知当前用来多少个long来代表总的长度。
代码@3：如果取反不为0，则说明用这个long代表的64个PoolSubpage未使用完，可用从这里获取一个，故进入到代码@4。
private int findNextAvail0(int i, long bits) {
final int maxNumElems = this.maxNumElems;
final int baseVal = i << 6; //@5
for (int j = 0; j < 64; j ++) { //遍历，一个long总代表64个PoolSubpage
if ((bits & 1) == 0) { //@6
int val = baseVal | j; //@8
if (val < maxNumElems) {
return val;
} else {
break;
}
}
bits >>>= 1; //@7
}
return -1;
}
代码@5：baseVal = i << 6,也就是i * 64,如果i在bitmap数组中的下标为0,baseVal则等于0，如果下标为1,则baseVal=64,如果下标为2，则baseVal=128。
代码@6：用bits&1判断是否等于0，也就是判断bits的低位是否被占用，如果为1，则表示被占用，如果为0，表示未被占用，如果结果为0，则可以返回该值了，如果不为0，则无符号向右移动1位，相当与去掉最后一位，继续比较。从这里就可以看出，一个long从低位开始被标记。我们举例说明一下，比如现在 用两个long类型可以标记所有的PoolSubpage,比如bitmap[0] = (00000000 00000000 00000000 00000000 00000000 00000000 00000000 0111111),表示已经分配了7个PoolSubpage。
代码 toHandle方法详解：
private long toHandle(int bitmapIdx) {
return 0xb000000000000000L | (long) bitmapIdx << 32 | memoryMapIdx;
}
该值，主要是用一个long类型的值的低32位来表示 memoryMapIdx,用高32位表示 bitmapIdx,这里为什么需要与0xb000000000000000L进行或运算呢？据我的目前掌握的知识看，主要是将0映射为一个数字，主要来区分是在PoolSubpage中分配的，还是内存大于pageSize,在内存释放的时候，可以通过bitmaIdx >> 32 & 0x3FFFFFFF 得出原来的索引。
1.3.1.4 关于 PoolArena allocate代码@4 initBuf详解：
void initBuf(PooledByteBuf buf, long handle, int reqCapacity) {
int memoryMapIdx = (int) handle;//@1
int bitmapIdx = (int) (handle >>> Integer.SIZE); //@2
if (bitmapIdx == 0) {//@3
byte val = value(memoryMapIdx);
assert val == unusable : String.valueOf(val);
buf.init(this, handle, runOffset(memoryMapIdx), reqCapacity, runLength(memoryMapIdx));
} else {//@4
initBufWithSubpage(buf, handle, bitmapIdx, reqCapacity);
}
}
首先这里对入参 long handle做一个详解：如果需要分配的内存大于pageSize,则返回的高32为为0，低32位为memoryMap的下标id。具体参照下文的allocateRun方法讲解；如果需要分配的内存小于pageSize,则返回的高32为为bitmapIdx，低32位同样表示memoryMap的id。
代码@1：从long中获取memoryMapIdx。
代码@2：从long中获取bitmapIdx。
代码@3：如果bitmapIdx为0，偏移量就是PoolSubpage的偏移量。为什么呢？bitmapIdx为0在内存申请大于pageSize和小于pageSize时都会出现：
-
如果申请的内存数小于pageSize,bitmapIdx表示该pageSubpage是第一次分配。
-
如果申请的内存数大于pageSize,表明该节点所以子节点都是第一次被分片。故偏移量就是memory[id]所代表的偏移量。
代码@4：如果bitmapIdx不为0，需要计算偏移量，与PoolSubpage的elemSize相关，具体请看2)PoolChunk的initBufWithSubpage方法,该方法，最终还是要调用PooledByteBuf的init方法，分配内存，这里只是需要计算偏远量。
1、PooledByteBuf的 int方法
void init(PoolChunk chunk, long handle, int offset, int length, int maxLength) {
assert handle >= 0;
assert chunk != null;
this.chunk = chunk;
this.handle = handle;
memory = chunk.memory; // @1
this.offset = offset; // @2
this.length = length; // @3
this.maxLength = maxLength; // @4
setIndex(0, 0); //@5
tmpNioBuf = null;
initThread = Thread.currentThread();//@6
}
代码@1：PooledByteBuf的内存，直接指向PoolChunk的memory；
代码@2：offset,在memory的起始偏移量。
代码@3：memory的offset + length之间的内存被该PooledByteBuf占用，其他ByteBuf无法使用。
代码@4：maxLength的作用是什么呢？目前我的理解是，PooledByteBuf自动扩容时，只要最终长度不超过maxLength，就可以在当前的内存中完成，不需要去申请新的空间，再进行内存负责。
代码@5：初始化readIndex,writeIndex。
代码@6：记录该PooledByteBuf的初始化线程，方便本地线程池的使用。
2、PoolChunk的iinitBufWithSubpage方法详解
private void initBufWithSubpage(PooledByteBuf buf, long handle, int bitmapIdx, int reqCapacity) {
assert bitmapIdx != 0;
int memoryMapIdx = (int) handle;
PoolSubpage subpage = subpages[subpageIdx(memoryMapIdx)];
assert subpage.doNotDestroy;
assert reqCapacity <= subpage.elemSize;
buf.init(
this, handle,
runOffset(memoryMapIdx) + (bitmapIdx & 0x3FFFFFFF) * subpage.elemSize, reqCapacity, subpage.elemSize);
}
1.3.2 PoolChunk allocate关于代码@allocateRun，超过pageSize内存分配源码分析
/**
-
Allocate a run of pages (>=1)
-
@param normCapacity normalized capacity
-
@return index in memoryMap
*/
private long allocateRun(int normCapacity) {
int d = maxOrder - (log2(normCapacity) - pageShifts); //@1
int id = allocateNode(d); //@2
if (id < 0) {
return id;
}
freeBytes -= runLength(id); //@3
return id;
}
该方法的实现，就是要在平衡二叉树中要找到一个可以满足normCapacity的节点，从前文的介绍中得知，memoryMap[id]存放的是，该id能分配的最小深度代表的容量。超过pageSize的内存节点，肯定不是在叶子节点。如果让我实现查找合适id的算法，我想应该是这样的：
1、算成需要分配的内存大小是 pageSize的倍数，再直观点就是normalCapacity 是 pageSize 的倍数n，然后算成n是2的多少次幂，比如pageSize=4,而normalCapacity是16，得出的倍数是4,4是2的2次幂，最终要得到这个值。标记为r
2、然后从平衡二叉树，沿着最底层（高度为0，深度为maxOrder），向上找r级，即能知道这一层次的节点可以容纳下normaCapacity的节点。
代码@1：先算出normCapacity，2的对（2的幂)然后减去pageSize（2的幂），得出思路1的r的值，然后用maxOrder-r,就表示深度最大为maxOrder-r。
代码@2：沿着平衡二叉树，从根节点开始，寻找一个合适的节点。如果无法分配，返回-1。
allocateNode(id)在上文中已经讲解，为了增深映像，在这里将代码再次粘贴：
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);
if (val > d) { // unusable
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;
val = value(id);
if (val > d) {
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); // mark as unusable
updateParentsAlloc(id);
return id;
}
1.3.3 关于PoolArena 2.2.2 allocate方法的代码@5allocateHuge方法详解
在netty内存管理中，如果超过chunkSize的内存，为大内存，不重复使用。
private void allocateHuge(PooledByteBuf buf, int reqCapacity) {
buf.initUnpooled(newUnpooledChunk(reqCapacity), reqCapacity);
}
PoolArena.HeapArena：
protected PoolChunk<byte[]> newUnpooledChunk(int capacity) {
return new PoolChunk<byte[]>(this, new byte[capacity], capacity);
}
PoolChunk非池管理的PoolChunk：
/** Creates a special chunk that is not pooled. */
PoolChunk(PoolArena arena, T memory, int size) {
unpooled = true;
this.arena = arena;
this.memory = memory;
memoryMap = null;
depthMap = null;
subpages = null;
subpageOverflowMask = 0;
pageSize = 0;
pageShifts = 0;
maxOrder = 0;
unusable = (byte) (maxOrder + 1);
chunkSize = size;
log2ChunkSize = log2(chunkSize);
maxSubpageAllocs = 0;
}
大内存的PoolChunk,不缓存使用，故内部不会再细化为PoolSubpage等数据结构。
void initUnpooled(PoolChunk chunk, int length) {
assert chunk != null;
this.chunk = chunk;
handle = 0;
memory = chunk.memory;
offset = 0;
this.length = maxLength = length;
setIndex(0, 0);
tmpNioBuf = null;
initThread = Thread.currentThread();
}
PooledByteBuf来初始化是，lengt,maxLenth等于需要申请的内存。看过tiny,small内存的分配后，大内存的分配比较简单，就不做每行代码的解读。不容易呀，Netty内存的分配就讲解完毕了。接下来注重分析两个方面：内存释放与PooledByteBuf动态扩容。
2、源码分析Netty内存释放
===============
在讲解Netty内存释放之前，我们还是简单的再回顾一下ReferenceCounted,Netty的ByteBuf继承该接口，这也表明，Netty内部的内存管理是基于引用计数来进行内存的回收的。具体的实现是AbstractReferenceCounted。所以，我们在使用PooledByteBuf时，用完后要记得调用release方法。在线程本地分配时会再次强调，如果PooledByteBuf在用完后，没有调用realse方法，是无法被线程共用的。内存的释放入口，是ByteBuf的relase方法，也就是AbstractReferenceCountedByteBuf的release方法：
public final boolean release(int decrement) {
if (decrement <= 0) {
throw new IllegalArgumentException(“decrement: " + decrement + " (expected: > 0)”);
}
for (;😉 {
int refCnt = this.refCnt;
if (refCnt < decrement) {
throw new IllegalReferenceCountException(refCnt, -decrement);
}
if (refCntUpdater.compareAndSet(this, refCnt, refCnt - decrement)) {
if (refCnt == decrement) {
deallocate();
return true;
}
return false;
}
}
}
该方法的方式是循环利用CAS将引用减少，直到引用为0，则调用释放方法，ByteBuf的内存释放，不同子类，不同的实现，故deallocate方法为抽象方法；
/**
- Called once {@link #refCnt()} is equals 0.
*/
protected abstract void deallocate();
3.1 PooledByteBuf deallocate方法详解
protected final void deallocate() {
if (handle >= 0) {
final long handle = this.handle;
this.handle = -1;
memory = null;
boolean sameThread = initThread == Thread.currentThread();
initThread = null;
chunk.arena.free(chunk, handle, maxLength, sameThread); //@1
recycle(); //@2
}
}
内存释放的基本实现：首先将PooledByteBuf内部的handle修改为-1，将memory设置为null,，然后释放占用的内存，然后将该PooledByteBuf放入对象池。从这里也可以看出，PooledByteBuf ,不仅ByteBuf内部持有的缓存区会被回收，连PooledByteBuf这个对象本身，也会放入到对象池，供重复利用（线程级）。
2.1关于PooledByteBuf deallocate 代码@1 PoolArena的free方法，内存释放
/**
-
@param chunk
-
@param handle,内存分配，保存着bitmapIdx,memoryMapIdx
-
@param normaCapacity 申请的内存(释放的内存，取值为PooledByteBuf的 maxLenth)
-
@param 释放该PooledByteBuf的线程释放时创建该PooledByteBuf的线程
*/
void free(PoolChunk chunk, long handle, int normCapacity, boolean sameThreads) {
if (chunk.unpooled) { //@1
destroyChunk(chunk);
} else {
if (sameThreads) { //@2
PoolThreadCache cache = parent.threadCache.get();
if (cache.add(this, chunk, handle, normCapacity)) {
// cached so not free it.
return;
}
}
synchronized (this) { //@3
chunk.parent.free(chunk, handle);
}
}
}
如果是非池的内存，也就是大内存，直接释放，如果释放的线程是创建该PooledByteBuf的线程，则放入线程本地变量中，重复利用，此时不需要释放。如果不是，则释放内存。
代码@1：我们看一下PoolArena.HeapArena和DirectArena的分别实现：
PoolArena.HeapArena
protected void destroyChunk(PoolChunk<byte[]> chunk) {
// Rely on GC.
}
PoolArena.DirectArena:
protected void destroyChunk(PoolChunk chunk) {
PlatformDependent.freeDirectBuffer(chunk.memory); //释放堆外内存
}
代码@2：放入本地线程缓存中，这个稍后重点关注。
代码@3：释放内存，这里的内存释放与第一步的内存释放不同，第一步的内存释放，是直接将内存还给JVM堆、或操作系统。而这里的是在PoolChunk中进行标记与释放而已。chunk.parent指的是该PoolChunk的PoolChunkList对象。先重点进入到PoolChunk的free方法。
2.2 关于PoolArena.free方法 代码@3的讲解，此处主要是调用PoolChunk方法进行内存的释放：
/**
-
Free a subpage or a run of pages
-
When a subpage is freed from PoolSubpage, it might be added back to subpage pool of the owning PoolArena
-
If the subpage pool in PoolArena has at least one other PoolSubpage of given elemSize, we can
-
completely free the owning Page so it is available for subsequent allocations
-
@param handle handle to free
*/
void free(long handle) {
int memoryMapIdx = (int) handle; //@1
int bitmapIdx = (int) (handle >>> Integer.SIZE); //@2
if (bitmapIdx != 0) { // free a subpage //@3
PoolSubpage subpage = subpages[subpageIdx(memoryMapIdx)];
assert subpage != null && subpage.doNotDestroy;
if (subpage.free(bitmapIdx & 0x3FFFFFFF)) {
return;
}
}
freeBytes += runLength(memoryMapIdx); //@4
setValue(memoryMapIdx, depth(memoryMapIdx)); //@5
updateParentsFree(memoryMapIdx); //@6
}
代码@1：获取在memoryMap的下标。
代码@2：获取bitmapIdx。
代码@3：如果bitmapIdx不等于0，表示该内存是从PoolSubpage中直接分配的（内存申请时，小于pageSize）。此时内存的释放，直接调用PoolSubpage的free方法。
代码@4，@5，@6：如果申请的内存超过了pageSize，首先将freeBytes增加，然后在代码@5，将memoryMapIdx处的值更新为原先depth的值，代表可以重新分片深度为depth[id]的内存了，级联更新memoryMap,的父节点的释放状态。
2.3 关于 PoolArena.free方法,代码@3， PoolSubpage.free方法详解。
/**
-
@return {@code true} if this subpage is in use.
-
{@code false} if this subpage is not used by its chunk and thus it's OK to be released.
*/
boolean free(int bitmapIdx) {
if (elemSize == 0) {
return true;
}
int q = bitmapIdx >>> 6; //@1
int r = bitmapIdx & 63; //@2
assert (bitmap[q] >>> r & 1) != 0;
bitmap[q] ^= 1L << r; //@3
setNextAvail(bitmapIdx); //@4
if (numAvail ++ == 0) { //@5 start
addToPool();
return true;
}
if (numAvail != maxNumElems) {
return true;
} else {
// Subpage not in use (numAvail == maxNumElems)
if (prev == next) {
// Do not remove if this subpage is the only one left in the pool.
return true;
}
// Remove this subpage from the pool if there are other subpages left in the pool.
doNotDestroy = false;
removeFromPool();
return false;
} //@5 end
}
代码@1：求出bitmapIdx在bitmap数组中的下标。
代码@3：就是bitmapIdx在bitmap[q]下所对应的高位1，设置为0，表示可以再次被用来分配。
代码@4：将bitmapIdx设置为下一个可以用nextAvail,这时在nextAvail>0，分配时候就会直接先用释放的，保证内存的连续性。
代码@5：如果PoolSubpage有剩余空间后，加入到PoolArena的tinyPoolSubpages[]或smallPoolSubpages[]中。如果空间全部分配后，或一个都没分配，从PoolArena的tinyPoolSubpages[],smallPoolSubpages[]中移除。
3.3 关于PoolArena.free方法，代码@6，级联更新释放状态详解
/**
-
Update method used by free
-
This needs to handle the special case when both children are completely free
-
in which case parent be directly allocated on request of size = child-size * 2
-
@param id id
*/
private void updateParentsFree(int id) {
int logChild = depth(id) + 1;
while (id > 1) {
int parentId = id >>> 1;
byte val1 = value(id);
byte val2 = value(id ^ 1);
logChild -= 1; // in first iteration equals log, subsequently reduce 1 from logChild as we traverse up
if (val1 == logChild && val2 == logChild) {
setValue(parentId, (byte) (logChild - 1));
} else {
byte val = val1 < val2 ? val1 : val2;
setValue(parentId, val);
}
id = parentId;
}
}
这个算法在理解了上文的updateParentsAllocator()方法后，不难理解，只要我们明确一点，memoryMap[id]=order,表示id代表的节点，可以胜任大于等于order深度的内存分配需要。
3、PooledByteBuf内存扩容
===================
在讲解这个问题的时候，不知道大家有没有注意到PooledByteBuf的maxLength属性？该属性有和作用，请看下文分解。
PooledByteBuf扩容算法，请看capacity(int newCapacity)；
@Override
public final ByteBuf capacity(int newCapacity) {
ensureAccessible();
// If the request capacity does not require reallocation, just update the length of the memory.
if (chunk.unpooled) { //@1
if (newCapacity == length) {
return this;
}
} else {
if (newCapacity > length) { //@2
最后
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！
如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
updateParentsAllocator()方法后，不难理解，只要我们明确一点，memoryMap[id]=order,表示id代表的节点，可以胜任大于等于order深度的内存分配需要。
3、PooledByteBuf内存扩容
===================
在讲解这个问题的时候，不知道大家有没有注意到PooledByteBuf的maxLength属性？该属性有和作用，请看下文分解。
PooledByteBuf扩容算法，请看capacity(int newCapacity)；
@Override
public final ByteBuf capacity(int newCapacity) {
ensureAccessible();
// If the request capacity does not require reallocation, just update the length of the memory.
if (chunk.unpooled) { //@1
if (newCapacity == length) {
return this;
}
} else {
if (newCapacity > length) { //@2
最后
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-s83qTcTQ-1714933896901)]
[外链图片转存中…(img-ja1wj5Qc-1714933896902)]
[外链图片转存中…(img-lIeNe25c-1714933896902)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！
如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
392
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
