Netty学习之旅------源码分析Netty线程本地分配机制与PooledByteBuf线程级对象池原理分析(1)

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）

正文

}

return cache(tinySubPageHeapCaches, idx);

}

/**

• Try to allocate a small buffer out of the cache. Returns {@code true} if successful {@code false} otherwise

*/

boolean allocateNormal(PoolArena<?> area, PooledByteBuf<?> buf, int reqCapacity, int normCapacity) {

return allocate(cacheForNormal(area, normCapacity), buf, reqCapacity);

}

private MemoryRegionCache<?> cacheForNormal(PoolArena<?> area, int normCapacity) {

if (area.isDirect()) {

int idx = log2(normCapacity >> numShiftsNormalDirect);

return cache(normalDirectCaches, idx);

}

int idx = log2(normCapacity >> numShiftsNormalHeap); //@1

return cache(normalHeapCaches, idx);

}

private boolean allocate(MemoryRegionCache<?> cache, PooledByteBuf buf, int reqCapacity) {

if (cache == null) {

// no cache found so just return false here

return false;

}

boolean allocated = cache.allocate(buf, reqCapacity); //@2

if (++ allocations >= freeSweepAllocationThreshold) {

allocations = 0;

trim(); //@3

}

return allocated;

}

代码@1：根据需要申请的内存定位数组的下标，根据上文讲解的数组长度计算逻辑，相应的定位算法就显而易见了。

代码@2：MeomoryRegionCache内部持有的 Entry entries[]数组是真正持有内存的单元，故现在将重点转移到MemoryRegionCache的讲解中。

代码@3：如果分配次数达到freeSweepAllocationThreshold，进行一次尝试释放一次。具体代码见 trim()方法的讲解。

1.2.1 关于PoolThreadCache allocateForTiny 之MemoryRegionCache 源码解读【针对1.2代码@2】

1）MemoryRegionCache属性与构造方法详解

private final Entry[] entries; //MemoryRegionCache真正持有内存的地方

/*

private static final class Entry {

PoolChunk chunk; //具体的PoolChunk

long handle; //内存持有偏移量，高32位保存的是bitmaIdx,低32位保存的是memoryMapIdx

}

*/

private final int maxUnusedCached; //表示允许的最大的没有使用的内存数量（已经被缓存），默认为size的一半。

private int head; // 作用类似于ByteBuf的readerIndex,从该位置获取一个缓存的Entiry。

private int tail; // 作用类似于ByteBuf的writerIndex,从该位置增加一个加入一个新的Entity

private int maxEntriesInUse; // 在使用中最大的entry数量

private int entriesInUse; // 目前使用中的entry数量

@SuppressWarnings(“unchecked”)

MemoryRegionCache(int size) { // size 默认的大小为 512， 256， 64

entries = new Entry[powerOfTwo(size)];

for (int i = 0; i < entries.length; i++) {

entries[i] = new Entry();

}

maxUnusedCached = size / 2; //允许被缓存，但没有使用的最大数量，超过该值，则会触发内存释放操作。

}

初始状态的MemoryRegionCache的各个属性的值分别为：

maxUnusedCached :   256,128,32,为size的一半;head:0 ;tail:0 ; maxEntriesInUse : 0; entriesInUse : 0

2）MemoryRegionCache的allocate方法详解

/**

• Allocate something out of the cache if possible and remove the entry from the cache.

*/

public boolean allocate(PooledByteBuf buf, int reqCapacity) {

Entry entry = entries[head]; //@1

if (entry.chunk == null) { //@2

return false;

}

entriesInUse ++; //@3

if (maxEntriesInUse < entriesInUse) {

maxEntriesInUse = entriesInUse;

}

initBuf(entry.chunk, entry.handle, buf, reqCapacity); //@4

// only null out the chunk as we only use the chunk to check if the buffer is full or not.

entry.chunk = null; //@5

head = nextIdx(head); //@6

return true;

}

代码@1：从entries数组中获取一个entry,head指针表示下一个缓存的Entry。

代码@2：如果entry.chunk为空，则表示线程里暂未缓存内存，返回false，表示从本地线程中分配失败。

代码@3：每分配出一个Entry,则entriesInUse加1，表示正在使用的entry个数。

代码@5：用entry中的内存初始化ByteBuf。

代码@6：head指针加一，如果超过entries的length，则重新从0开始，其实也就是  (head + 1) % (entires.length - 1),这里使用的是位运算。如果成功分配，则返回true, 结束本次内存的分配。

1.2.3 关于PoolThreadCache allocateForTiny 之代码@3，trim方法详解：

该方法的目的是在本地线程分配达到一定次数后，检测一下从本地线程缓存分配的效率，如果总是分配不到，就是虽然本地有缓存一定的内存，但每次分配都没有找到合适内存供分配，此时需要释内存回全局分配池，避免浪费内存。

void trim() {

trim(tinySubPageDirectCaches);

trim(smallSubPageDirectCaches);

trim(normalDirectCaches);

trim(tinySubPageHeapCaches);

trim(smallSubPageHeapCaches);

trim(normalHeapCaches);

}

private static void trim(MemoryRegionCache<?>[] caches) {

if (caches == null) {

return;

}

for (MemoryRegionCache<?> c: caches) {

trim©;

}

}

private static void trim(MemoryRegionCache<?> cache) {

if (cache == null) {

return;

}

cache.trim();

}

trim的具体实现是MemoryRegionCache,现在进入到MemoryRegionCache详解：

/**

• Free up cached {@link PoolChunk}s if not allocated frequently enough.

*/

private void trim() {

int free = size() - maxEntriesInUse; //@1

entriesInUse = 0;

maxEntriesInUse = 0; //@2

if (free <= maxUnusedCached) { //@3

return;

}

int i = head;

for (; free > 0; free–) {

if (!freeEntry(entries[i])) {

// all freed

break;

}

i = nextIdx(i);

}

// Update head to point to te correct entry

// See https://github.com/netty/netty/issues/2924

head = i;

}

在进行该方法的实现逻辑之前，我先提供一张草图，形象的反映head,tail等说明：

代码@1：size()方法返回的是  (tail-head) & (length-1),表示当前缓存了但未被使用的个数。maxEntriesInUse的值，其实就是entiryesInUse的值。

代码@2：代码@3，如果缓存的并且未使用的个数如果小于允许的值（maxUnusedCached)值是放弃本次内存释放，否则，需要将head到tail这部分的内存全部释放，返回给全局内存分配池。这里我可能没有理解透彻，如果是我实现的话，entriesInUse该值不会设置为空，而是直接释放掉 tail-head这部分的内存就好，释放算法在内存分配与释放篇已经做过详细解读，这里不重复讲解：

@SuppressWarnings({ “unchecked”, “rawtypes” })

private static boolean freeEntry(Entry entry) {

PoolChunk chunk = entry.chunk;

if (chunk == null) {

return false;

}

// need to synchronize on the area from which it was allocated before.

synchronized (chunk.arena) {

chunk.parent.free(chunk, entry.handle);

}

entry.chunk = null;

return true;

}

扫描一下MemoryRegionCache类，还有一个方法我们未曾分析过，就是add方法，默认一开始MemoryRegionCache类中的Entry[] entries中的PoolChunk与handle都是空的，只有通过该add方法，将线程用过的内存缓存起来才能重复使用。我们要养成这样一个习惯，一个ByteBuf用过后，需要调用realse方法将其释放，具体到池化的PooledByteBuf，调用其realse方法，并不会将内存直接返还给JVM堆，而是放入到内存池，供重复使用，由于引入了线程本地缓存，所以在调用PooledByteBuf的release方法时，并不会将它立马返回给内存池(PoolArena)，而是放入到本地线程缓存中。

/**

• Add to cache if not already full.

*/

public boolean add(PoolChunk chunk, long handle) {

Entry entry = entries[tail];

if (entry.chunk != null) {

// cache is full

return false;

}

entriesInUse --;

entry.chunk = chunk;

entry.handle = handle;

tail = nextIdx(tail);

return true;

}

本地线程池关于内存的分配与释放旧梳理到这里了。

2、PooledByteBuf线程本地缓存专题(线程对象池)

==============================

到目前为止，我们更加关注的是PooledByteBuf内部持有的内存的管理，重复利用，显然Netty并不满足与此，PooledByteBuf本身是否也可以缓存呢？是的，一样可以缓存，并且netty从PooledByteBuf对象本身，指向的内存从两个方面进行缓存，回收利用，并不是将单一某个面进行一起缓存。下文，将从PooledByteBuf对象的回收利用这一层面进行Netty本地线程池来进行PooledByteBuf的重复利用。重复声明一下，PooledByteBuf对象池中缓存的PooledByteBuf,并没有任何缓存区（byte[]或java.nio.ByteBuffer）关联，只是PooledByteBuf本身，从对象池中获取一个PooledByteBuf后，还需要调用initBuf等方法进行内存的分配。

请看如下代码片段：来自PooledHeapByteBuf:

private static final Recycler RECYCLER = new Recycler() {

@Override

protected PooledHeapByteBuf newObject(Handle handle) {

return new PooledHeapByteBuf(handle, 0);

}

};//@2

static PooledHeapByteBuf newInstance(int maxCapacity) {

PooledHeapByteBuf buf = RECYCLER.get(); //@1

buf.setRefCnt(1);

buf.maxCapacity(maxCapacity);

return buf;

}

关注代码@1,@2创建一个PooledHeapByteBuf,是从一个静态变量 RECYLER的get方法中获取，代码@2的写法是不是和ThreadLocal的使用非常类似，所以本专题的主角，就非Recycler莫属了。

2.1 Recycler构造方法核心属性

---

private static final int DEFAULT_MAX_CAPACITY; //对象池默认的最大容量

private static final int INITIAL_CAPACITY; //初始容量

private final int maxCapacity; //对象池的容量，由构造方法中进行初始化，默认为DEFAULT_MAX_CAPACITY。

private final FastThreadLocal<Stack> threadLocal = new FastThreadLocal<Stack>() {

@Override

protected Stack initialValue() {

return new Stack(Recycler.this, Thread.currentThread(), maxCapacity);

}

};

Recycler不是一普通的对象池，而是基于线程本地变量（缓存）实现的对象池，所以此处的threadLocal是Recycler中至关重要的数据结构。我们可以看出，Recycler为每个线程保持的是一叫Stack的对象。先跳过Statck,我们看一下Recycler对外提供了哪些方法供我们使用：

@SuppressWarnings(“unchecked”)

public final T get() {

Stack stack = threadLocal.get();

DefaultHandle handle = stack.pop();

if (handle == null) {

handle = stack.newHandle();

handle.value = newObject(handle);

}

return (T) handle.value;

}

public final boolean recycle(T o, Handle handle) {

DefaultHandle h = (DefaultHandle) handle;

if (h.stack.parent != this) {

return false;

}

h.recycle(o);

return true;

}

看到这里，为了摸清楚Recycler的内部实现原理，我们只能将目光先投向Stack类。但一看又发现Statck内部维护着这样一个数据结构：DefaultHandle<?>[] elements;也就是一个Statck类维护这样一个DefaultHandle数组，所以，我们先将目光锁定在DefaultHandle上：

2.2 DefaultHandle源码详解

---

DefaultHandle，是对象池中最基本的单元，由该对象包裹着实际缓存的对象。

public interface Handle { //负责对象回收接口

void recycle(T object);

}

static final class DefaultHandle implements Handle {

private int lastRecycledId; //@1

private int recycleId; //@2,这两个属性待分解

private Stack<?> stack; //该Handle所在的Statck对象，上面也谈到，Statck维护一个Handle数组

private Object value; //该对象就是对象池缓存的对象，这里用 private T value更合适。

DefaultHandle(Stack<?> stack) { // 构造函数

this.stack = stack;

}

@Override

public void recycle(Object object) {

if (object != value) {

throw new IllegalArgumentException(“object does not belong to handle”);

}

Thread thread = Thread.currentThread(); //@3

if (thread == stack.thread) { //@4

stack.push(this);

return;

}

// we don’t want to have a ref to the queue as the value in our weak map

// so we null it out; to ensure there are no races with restoring it later

// we impose a memory ordering here (no-op on x86)

//@5 start

Map<Stack<?>, WeakOrderQueue> delayedRecycled = DELAYED_RECYCLED.get();

WeakOrderQueue queue = delayedRecycled.get(stack);

if (queue == null) {

delayedRecycled.put(stack, queue = new WeakOrderQueue(stack, thread));

}

queue.add(this); // @5 end

}

}

代码@1，@2：待下文分解。

代码@3：获取当前释放的线程。

代码@4：如果释放当前的线程与Statck对象保持一致，直接将对象放入到该线程对象的Statck中即可。

代码@5：大意是说我们不希望当前调用recycle方法的线程与Handle对象中statck对象的线程竟然不一致，我们需要强制一个内存排序，这个我就有点懵逼了。先理解一下该代码的含义：

将Handle对象放入到收集线程的本地缓存中，存放的是一个 Map<Stack<?>, WeakOrderQueue>,然后将Handle加入到WeakOrderQueue中，WeakOrderQueue里面存放的对象是基于一个WeakReference，弱引用，在垃圾回收的时候会被清除掉，放入进对象池中的对象，在什么地方取出来呢？是在Statck的pop方法中吗？有待进一步跟踪学习，还有根据这个收集线程的本地变量存放的类型来看，是个Map,说明不只一个键值对，那这个收集线程是什么来头呢？以上两个问题，暂时缓一缓，先移步到Statck类，分析完后，才回过头来思考。

2.3 Statck 源码分析

---

看一段官方的介绍：

// we keep a queue of per-thread queues, which is appended to once only, each time a new thread other

// than the stack owner recycles: when we run out of items in our stack we iterate this collection

// to scavenge those that can be reused. this permits us to incur minimal thread synchronisation whilst

// still recycling all items.

首先对于Statck目前，我只能理解放入elements中的对象，放入队列中对象，处了DefaultHandle中的 delayedRercycled有放入，但整个Recycler中未有相关使用语句，应该是Netty有额外的线程来辅助回收，这是个待定的问题？需要我慢慢去寻址。目前先按照常规流程讲解Statck,并抛出相关问题，希望大家予以帮助：

2.3.1 重要属性与构造函数解析

final Recycler parent; //@1,Statck所在的对象池引用，回收器。

final Thread thread; // 该Statck对象关联的线程。

private DefaultHandle<?>[] elements; //存放具体对象的容器。

private final int maxCapacity; //允许存放的最大对象数，也就是elements数组的最大长度。

private int size; //当前elements中缓存对象的个数。

private volatile WeakOrderQueue head;

言尽于此，完结

无论是一个初级的 coder，高级的程序员，还是顶级的系统架构师，应该都有深刻的领会到设计模式的重要性。

• 第一，设计模式能让专业人之间交流方便，如下：

程序员A：这里我用了XXX设计模式

程序员B：那我大致了解你程序的设计思路了

• 第二，易维护

项目经理：今天客户有这样一个需求…

程序员：明白了，这里我使用了XXX设计模式，所以改起来很快

• 第三，设计模式是编程经验的总结

程序员A：B，你怎么想到要这样去构建你的代码

程序员B：在我学习了XXX设计模式之后，好像自然而然就感觉这样写能避免一些问题

• 第四，学习设计模式并不是必须的

程序员A：B，你这段代码使用的是XXX设计模式对吗？

程序员B：不好意思，我没有学习过设计模式，但是我的经验告诉我是这样写的

从设计思想解读开源框架，一步一步到Spring、Spring5、SpringMVC、MyBatis等源码解读，我都已收集整理全套，篇幅有限，这块只是详细的解说了23种设计模式，整理的文件如下图一览无余！

搜集费时费力，能看到此处的都是真爱！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
序员A：这里我用了XXX设计模式

程序员B：那我大致了解你程序的设计思路了

• 第二，易维护

项目经理：今天客户有这样一个需求…

程序员：明白了，这里我使用了XXX设计模式，所以改起来很快

• 第三，设计模式是编程经验的总结

程序员A：B，你怎么想到要这样去构建你的代码

程序员B：在我学习了XXX设计模式之后，好像自然而然就感觉这样写能避免一些问题

• 第四，学习设计模式并不是必须的

程序员A：B，你这段代码使用的是XXX设计模式对吗？

程序员B：不好意思，我没有学习过设计模式，但是我的经验告诉我是这样写的

[外链图片转存中…(img-8nXvWPF6-1713424070585)]

从设计思想解读开源框架，一步一步到Spring、Spring5、SpringMVC、MyBatis等源码解读，我都已收集整理全套，篇幅有限，这块只是详细的解说了23种设计模式，整理的文件如下图一览无余！

[外链图片转存中…(img-B7MhSyxQ-1713424070585)]

搜集费时费力，能看到此处的都是真爱！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-pRPLvlcU-1713424070586)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！