一、PoolThreadLocalCache
在申请池化内存时，netty并不会直接从内存池中申请，而是先从PoolThreadLocalCache获取，同样的release一个ByteBuf时并不会直接归还到内存池，而是先缓存在
PoolThreadLocalCache中
PoolThreadLocalCache继承了FastThreadLocal，FastThreadLocal类似JDK的ThreadLocal的作用，将对象和本地线程关联，它内部使用了一个叫
InternalThreadLocalMap的集合，这个集合内部使用数组实现，在初始化FastThreadLocal时会通过一个原子递增类获取一个下标，数据就存储在指定的下标上，这点和
ThreadLocal有比较大的区别，ThreadLocal是以ThreadLocal对象做key的，当产生hash冲突时需要往后顺延找坑位。所以要说FastThreadLocal与ThreadLocal最大区别是什么，
那就是存值的方式不同。
除此之外如果当前线程对象是FastThreadLocalThread类型，那么这个InternalThreadLocalMap直接是FastThreadLocalThread一个字段，就无需使用ThreadLocal去本地线程中获
取InternalThreadLocalMap集合了。
下面我们来看下PoolThreadLocalCache初始值方法
protected synchronized PoolThreadCache io.netty.buffer.PooledByteBufAllocator.PoolThreadLocalCache#initialValue() {
//遍历heapArenas，找出使用缓存的线程数最少的那个PoolArena
final PoolArena<byte[]> heapArena = leastUsedArena(heapArenas);
final PoolArena<ByteBuffer> directArena = leastUsedArena(directArenas);
final Thread current = Thread.currentThread();
//useCacheForAllThreads表示是否启用线程缓存
//FastThreadLocalThread是一个继承了Thread的线程对象，它有一个成员字段叫InternalThreadLocalMap
//InternalThreadLocalMap类似于JDK的Thread中的ThreadLocalMap
if (useCacheForAllThreads || current instanceof FastThreadLocalThread) {
final PoolThreadCache cache = new PoolThreadCache(
heapArena, directArena, tinyCacheSize, smallCacheSize, normalCacheSize,
DEFAULT_MAX_CACHED_BUFFER_CAPACITY, DEFAULT_CACHE_TRIM_INTERVAL);
//如果指定了定时清理缓存的时间，那么启动一个调度线程池去处理
if (DEFAULT_CACHE_TRIM_INTERVAL_MILLIS > 0) {
final EventExecutor executor = ThreadExecutorMap.currentExecutor();
if (executor != null) {
executor.scheduleAtFixedRate(trimTask, DEFAULT_CACHE_TRIM_INTERVAL_MILLIS,
DEFAULT_CACHE_TRIM_INTERVAL_MILLIS, TimeUnit.MILLISECONDS);
}
}
return cache;
}
// No caching so just use 0 as sizes.
//不允许使用缓存，创建一个空的PoolThreadCache
return new PoolThreadCache(heapArena, directArena, 0, 0, 0, 0, 0);
}
从上面的代码中可以看到，PoolThreadLocalCache内部缓存的是一个叫做PoolThreadCache的对象，这个对象才是最终记录释放的内存块的地方
二、PoolThreadCache
2.1 PoolThreadCache字段说明
//当前 PoolThreadCache 缓存的内存所属 PoolArena
final PoolArena<byte[]> heapArena;
final PoolArena<ByteBuffer> directArena;
//用于缓存tiny类型的堆内存，数组长度为 32
//MemoryRegionCache内部维护了一个队列，长度默认为512
private final MemoryRegionCache<byte[]>[] tinySubPageHeapCaches;
//用于缓存small类型的堆内存，数组长度为 4
//MemoryRegionCache内部队列长度默认为256
private final MemoryRegionCache<byte[]>[] smallSubPageHeapCaches;
//用于缓存tiny类型的直接内存，数组长度为 32
//MemoryRegionCache内部维护了一个队列，长度默认为512
private final MemoryRegionCache<ByteBuffer>[] tinySubPageDirectCaches;
//用于缓存small类型的直接内存，数组长度为 4
//MemoryRegionCache内部队列长度默认为256
private final MemoryRegionCache<ByteBuffer>[] smallSubPageDirectCaches;
//用于缓存normal类型的堆内存，数组长度默认为3
//MemoryRegionCache内部队列长度默认为64
private final MemoryRegionCache<byte[]>[] normalHeapCaches;
//用于缓存normal类型的直接内存，数组长度默认为3
//MemoryRegionCache内部队列长度默认为64
private final MemoryRegionCache<ByteBuffer>[] normalDirectCaches;
// Used for bitshifting when calculate the index of normal caches later
//计算直接内存的页偏移，默认是13 = log2(8k)
private final int numShiftsNormalDirect;
//计算堆内存的页偏移，默认是13 = log2(8k)
private final int numShiftsNormalHeap;
//缓存的内存被申请了 freeSweepAllocationThreshold 次以后将被清理，归还到内存池中
private final int freeSweepAllocationThreshold;
//原子类，用于确保io.netty.buffer.PoolThreadCache#free(boolean)方法只被调用一次
//free方法用于将PoolThreadCache缓存的内存都归还到内存池中
private final AtomicBoolean freed = new AtomicBoolean();
//记录从PoolThreadCache分配内存的次数
private int allocations;
2.2 PoolThreadCache.MemoryRegionCache
2.2.1 简介
MemoryRegionCache是具体记录内存块信息的地方，按照内存大小分成两个实现类，一个是SubPageMemoryRegionCache，另一个是NormalMemoryRegionCache，其主要原因是因为
初始化PooledByteBuf时，计算偏移的方式不一样，具体的初始化方式可翻看博文《netty内存池源码分析》
2.2.2 字段
//记录queue的元素个数
private final int size;
//缓存内存块
private final Queue<Entry<T>> queue;
//枚举，用于记录当前内存块所属类型，tiny，small or normal
private final SizeClass sizeClass;
//记录分配次数，每次从MemoryRegionCache分配内存，都会加1
private int allocations;
2.2.3 添加缓存对象
public final boolean MemoryRegionCache#add(PoolChunk<T> chunk, ByteBuffer nioBuffer, long handle) {
//(1)
Entry<T> entry = newEntry(chunk, nioBuffer, handle);
//存入队列
boolean queued = queue.offer(entry);
if (!queued) {
// If it was not possible to cache the chunk, immediately recycle the entry
//如果已经达到队列容量上限，那么就存不进去了，回收这个entry，供下次使用
entry.recycle();
}
return queued;
}
//(1)
private static Entry io.netty.buffer.PoolThreadCache.MemoryRegionCache#newEntry(PoolChunk<?> chunk, ByteBuffer nioBuffer, long handle) {
//从对象池中获取一个Entry
Entry entry = RECYCLER.get();
//记录内存块相关信息
//PoolChunk，表示当前缓存的内存块来自哪个内存池
entry.chunk = chunk;
//缓存当前内存块使用的ByteBuffer对象，用于ByteBuf转ByteBuffer时使用
entry.nioBuffer = nioBuffer;
//记录当前内存块在PoolChunk二叉树中的索引，如果是小于8k的，另外还会记录其在bitMap中的bit位索引
entry.handle = handle;
return entry;
}
可以看到，netty添加缓存的时候，将内存块的信息封装成了一个Entry对象存入到一个队列中，而为了避免创建对象的开销，netty使用了对象池去复用Entry对象。关于对象池
相关的内容可以查看博文《对象池》
2.2.4 分配内存
public final boolean io.netty.buffer.PoolThreadCache.MemoryRegionCache#allocate(PooledByteBuf<T> buf, int reqCapacity) {
//从队列中取一个Entry
Entry<T> entry = queue.poll();
//entry为null，缓存分配失败
if (entry == null) {
return false;
}
//成功，初始化PooledByteBuf
initBuf(entry.chunk, entry.nioBuffer, entry.handle, buf, reqCapacity);
entry.recycle();
// allocations is not thread-safe which is fine as this is only called from the same thread all time.
//分配次数加1
++ allocations;
return true;
}
2.2.5 内存的释放
内存的释放很简单，只要调用其持有的PoolChunk的free方法即可
2.3 PoolThreadCache的构造器
PoolThreadCache(PoolArena<byte[]> heapArena, PoolArena<ByteBuffer> directArena,
int tinyCacheSize, int smallCacheSize, int normalCacheSize,
int maxCachedBufferCapacity, int freeSweepAllocationThreshold) {
//检查maxCachedBufferCapacity参数，maxCachedBufferCapacity > 0
checkPositiveOrZero(maxCachedBufferCapacity, "maxCachedBufferCapacity");
this.freeSweepAllocationThreshold = freeSweepAllocationThreshold;
this.heapArena = heapArena;
this.directArena = directArena;
if (directArena != null) {
//创建用于缓存tiny类型内存块的MemoryRegionCache数组，数组长度为32
//MemoryRegionCache内部队列长度默认为512
tinySubPageDirectCaches = createSubPageCaches(
tinyCacheSize, PoolArena.numTinySubpagePools, SizeClass.Tiny);
//创建用于缓存small类型内存块的MemoryRegionCache数组，数组长度为4
//MemoryRegionCache内部队列长度默认为256
smallSubPageDirectCaches = createSubPageCaches(
smallCacheSize, directArena.numSmallSubpagePools, SizeClass.Small);
//页偏移，pageSize默认为8k，所以偏移值为13
numShiftsNormalDirect = log2(directArena.pageSize);
//创建用于缓存normal类型内存块的MemoryRegionCache数组，数组长度默认为3
//MemoryRegionCache内部队列长度默认为64
normalDirectCaches = createNormalCaches(
normalCacheSize, maxCachedBufferCapacity, directArena);
//递增，表示当前PoolArena所管理的内存池已被多少线程缓存
directArena.numThreadCaches.getAndIncrement();
}
。。。。。。省略创建堆PoolArean的代码，和创建直接内存的PoolArean是一样的
}
从构造器中可以看到，PoolThreadCache按照分配内存的大小分成了三种类型的缓存，tiny，small，normal
- tiny数组长度的为32，分别表示0,16,32…480,496，相邻元素直接相差16字节
- small类型的数组长度为4，分别表示512,1024,2048,4096，相邻元素之间相差2倍
- normal数组的长度默认是3，相邻元素之间的能够储存的最小值相差2被，最大值也是相差2倍，每个元素的范围相差两倍，能够存储的值不包含最大值，由于Netty会将内存大小修正为2的n次幂的值，所以其实下面的图也就只能存 8k, 16k, 32k这样的内存值
2.4 添加缓存数据
boolean io.netty.buffer.PoolThreadCache#add(PoolArena<?> area, PoolChunk chunk, ByteBuffer nioBuffer,
long handle, int normCapacity, SizeClass sizeClass) {
//(1)
MemoryRegionCache<?> cache = cache(area, normCapacity, sizeClass);
if (cache == null) {
return false;
}
//添加到MemoryRegionCache的队列中
return cache.add(chunk, nioBuffer, handle);
}
//(1)
private MemoryRegionCache<?> cache(PoolArena<?> area, int normCapacity, SizeClass sizeClass) {
switch (sizeClass) {
case Normal:
return cacheForNormal(area, normCapacity);
case Small:
return cacheForSmall(area, normCapacity);
case Tiny:
return cacheForTiny(area, normCapacity);
default:
throw new Error();
}
}
上面的逻辑不复杂，通过SizeClass判断当前是属于什么类型的内存缓存，然后找到对应类型的数组，计算下标，获取MemoryRegionCache，将值存入即可
- tiny类型的下标计算
static int tinyIdx(int normCapacity) {
//除以16即可
return normCapacity >>> 4;
}
- small类型的下标计算
static int smallIdx(int normCapacity) {
int tableIdx = 0;
//除以512，得到2的n次方的商
int i = normCapacity >>> 10;
//相当于log2(i)
while (i != 0) {
i >>>= 1;
tableIdx ++;
}
return tableIdx;
}
- normal类型的下标计算
//numShiftsNormalDirect为13，normCapacity >> numShiftsNormalDirect相当于除以pageSize
int idx = log2(normCapacity >> numShiftsNormalDirect);
2.5 分配缓存数据
看了前面缓存数据的存储和MemoryRegionCache的内存分配，不用看代码都知道，首先确定是哪种类型的内存分配，然后计算下标，获取对应MemoryRegionCache，从其队列中
poll一个Entry，最后对PooledByteBuf初始化即可。
三、总结
Netty在释放或者分配内存池内存时，为了性能考虑，并不会直接从内存池中进行分配与释放，而是先从本地线程中获取缓存或者添加缓存。记录缓存的类PoolThreadCache按照
内存的大小，分成了tiny，small，normal三块缓存域，每个域都是使用数组加队列实现的，tiny数组长度默认32，相邻元素之间相差16，每个元素中的队列大小默认为512；
small数组长度默认为4，相邻元素之间相差两倍，每个元素的队列大小默认为256；normal数组的长度默认为3，相邻元素之间能够缓存的最小内存大小之间相差2倍，每个元素
能够储存的范围为 (minMemory ~ 2minMemory（不含最大值，由于Netty会将内存大小修正为2的n次幂的值，所以其实也就只能存 8k, 16k, 32k这样的）)，队列大小默认为64。
