PooledByteBuf分配及回收之八分配小型PooledByteBuf（未命中缓存场景）

PooledByteBufAllocator初始化

PoolThreadCache初始化

PoolAerna初始化

PoolChunk初始化

PoolSubpage初始化

PooledUnsafeDirectByteBuf初始化

分配微小型PooledByteBuf（未命中缓存场景）

分配小型PooledByteBuf（未命中缓存场景）

分配普通型PooledByteBuf（未命中缓存场景）

PoolChunkList源码解析

ReferenceCountUpdater源码解析

Recycler及基内部类初始化

Recycler.Stack＜T＞ 压入对象

Recycler.Stack＜T＞ 弹出对象

PooledByteBuf的回收

先看上一篇分配微小型PooledByteBuf（未命中缓存场景）

小型Capacity     大于等于512 并且小于 8192（pageSize）   ~(8192 - 1) == -8192

小型与微小型的差别在于获取PoolSubpage的不同,小型是从PoolArena的smallSubpagePools数组中获取

smallSubpagePools数组长度为4

PoolArena的allocate(PoolThreadCache cache, PooledByteBuf<T> buf, final int reqCapacity)方法

private void allocate(PoolThreadCache cache, PooledByteBuf<T> buf, final int reqCapacity) {
        final int normCapacity = normalizeCapacity(reqCapacity); 
        //小于pageSzie（8192）的为微小型、小型
        if (isTinyOrSmall(normCapacity)) { // capacity < pageSize
            int tableIdx;
            PoolSubpage<T>[] table;
            //小于512的为微小型
            boolean tiny = isTiny(normCapacity);
            if (tiny) { // < 512
              
                if (cache.allocateTiny(this, buf, reqCapacity, normCapacity)) {
                    // was able to allocate out of the cache so move on
                    return;
                }
                tableIdx = tinyIdx(normCapacity);
                table = tinySubpagePools;
            } else {
                //>=512 && <8192  实际上是<=4096 因为大于4096的normalizeCapacity方法会返回8192
                if (cache.allocateSmall(this, buf, reqCapacity, normCapacity)) {
                    // was able to allocate out of the cache so move on
                    return;
                }
                tableIdx = smallIdx(normCapacity);
                table = smallSubpagePools;
            }

            final PoolSubpage<T> head = table[tableIdx];

            /**
             * 第一次分配的时候head.next == head 所以不会执行这段逻辑
             */
            synchronized (head) {
                final PoolSubpage<T> s = head.next;
                if (s != head) {
                    assert s.doNotDestroy && s.elemSize == normCapacity;
                    long handle = s.allocate();
                    assert handle >= 0;
                    s.chunk.initBufWithSubpage(buf, null, handle, reqCapacity);
                    incTinySmallAllocation(tiny);
                    return;
                }
            }
            synchronized (this) {
                allocateNormal(buf, reqCapacity, normCapacity);③
            }

            incTinySmallAllocation(tiny);
            return;
        }
        if (normCapacity <= chunkSize) {
            if (cache.allocateNormal(this, buf, reqCapacity, normCapacity)) {
                // was able to allocate out of the cache so move on
                return;
            }
            synchronized (this) {
                allocateNormal(buf, reqCapacity, normCapacity);
                ++allocationsNormal;
            }
        } else {
            // Huge allocations are never served via the cache so just call allocateHuge
            allocateHuge(buf, reqCapacity);
        }
    }


    //  >>> 10 相当于除以1024  所以smallSubpagePools中每个subPage均是1024的倍数
    static int smallIdx(int normCapacity) {
        int tableIdx = 0;
        int i = normCapacity >>> 10;
        while (i != 0) {
            i >>>= 1;
            tableIdx ++;
        }
        return tableIdx;
    }