Netty内存分配---线程缓存分配

PoolThreadCache的数据结构

 在一个PoolThreadCache中，有三个MemoryRegionCache数组用于存储tiny，small和normal类型的内存块。每个MemoryRegionCache中有一个队列，队列中的元素类型为Entry。Entry的作用就是存储缓存的内存块的，其存储的方式主要是通过记录当前内存块所在的PoolChunk和标志其在PoolChunk中位置的handle参数。对于不同类型的数组，队列的长度是不一样的，tiny类型的是512，small类型的是256，normal类型的则是64。

PoolThreadCache的构造：

PoolThreadCache是一个FastThreadLocal类型数据。初始化主要是直接内存的缓存和堆内存的缓存。以及一个Watcher线程，为了当线程意外结束时，确保内存一定被释放。出于性能考虑，Netty并没有使用一个常驻的后台Watcher线程，而是当有需要观察的线程时，才启动Watcher线程；当所有观察任务结束，Watcher线程也结束。线程结束时需要主动释放PoolThreadCache(如果是ftst，线程结束时会调用PoolThreadCache的onRemoval方法释放)，如果没有，watcher线程就会协助释放这块内存。

    PoolThreadCache(PoolArena<byte[]> heapArena, PoolArena<ByteBuffer> directArena,
                    int tinyCacheSize, int smallCacheSize, int normalCacheSize,
                    int maxCachedBufferCapacity, int freeSweepAllocationThreshold) {
        ... 省略参数检测 ...
        ...
        this.freeSweepAllocationThreshold = freeSweepAllocationThreshold;
        this.heapArena = heapArena;
        this.directArena = directArena;
        // 创建heapArea和directArena的缓存
        if (directArena != null) {
            tinySubPageDirectCaches = createSubPageCaches(
                    tinyCacheSize, PoolArena.numTinySubpagePools, SizeClass.Tiny);
            smallSubPageDirectCaches = createSubPageCaches(
                    smallCacheSize, directArena.numSmallSubpagePools, SizeClass.Small);

            numShiftsNormalDirect = log2(directArena.pageSize);
            normalDirectCaches = createNormalCaches(
                    normalCacheSize, maxCachedBufferCapacity, directArena);

            directArena.numThreadCaches.getAndIncrement();
        } else {
            // No directArea is configured so just null out all caches
            tinySubPageDirectCaches = null;
            smallSubPageDirectCaches = null;
            normalDirectCaches = null;
            numShiftsNormalDirect = -1;
        }
        ...省略heapArea的创建，和上面创建逻辑一致...
        ...
        // The thread-local cache will keep a list of pooled buffers which must be returned to
        // the pool when the thread is not alive anymore.
        ThreadDeathWatcher.watch(thread, freeTask);
    }

缓存中的内存来源：

    void free(PoolChunk<T> chunk, long handle, int normCapacity, PoolThreadCache cache) {
        if (chunk.unpooled) {
            int size = chunk.chunkSize();
            destroyChunk(chunk);
            activeBytesHuge.add(-size);
            deallocationsHuge.increment();
        } else {
            SizeClass sizeClass = sizeClass(normCapacity);
            if (cache != null && cache.add(this, chunk, handle, normCapacity, sizeClass)) {
                // cached so not free it.
                return;
            }

            freeChunk(chunk, handle, sizeClass);
        }
    }

ByteBuf.release()方法的时候，最终会到PoolArena的free()方法，PoolChunk则会判断当前是否是池化的ByteBuf，如果是池化的ByteBuf，则调用PoolThreadCache.add()方法将其添加到PoolThreadCache中，也就是说在释放内存时，其实际上是释放到当前线程的PoolThreadCache中的。如果不是池化或者缓存装不下了才会将内存释放到area里面。

添加到缓存的逻辑很简单，先根据大小找到对应的MemoryRegionCache(内部是queue装载内存)，然后加入到MemoryRegionCache的queue里面。如果添加失败，就会释放这块内存到area。

缓存分配内存：

    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);
        if (++ allocations >= freeSweepAllocationThreshold) {
            allocations = 0;
            trim();
        }
        return allocated;
    }

先根据大小找到对应的MemoryRegionCache(内部是queue装载内存)，然后直接分配一个给他。如果分配到一定次数(默认8192)还会调用trim来调整内存。

trim的逻辑就是检测整个cache中的所有MemoryRegionCache，把未分配的内存全部释放到area中，防止出现内存泄漏。

   // trim所有数组
    void trim() {
        trim(tinySubPageDirectCaches);
        trim(smallSubPageDirectCaches);
        trim(normalDirectCaches);
        trim(tinySubPageHeapCaches);
        trim(smallSubPageHeapCaches);
        trim(normalHeapCaches);
    }
    // 遍历数组中的所有MemoryRegionCache
    private static void trim(MemoryRegionCache<?>[] caches) {
        if (caches == null) {
            return;
        }
        for (MemoryRegionCache<?> c: caches) {
            trim(c);
        }
    }

    private static void trim(MemoryRegionCache<?> cache) {
        if (cache == null) {
            return;
        }
        cache.trim();
    }
    //
    public final void trim() {
            int free = size - allocations;
            allocations = 0;

            // We not even allocated all the number that are
            if (free > 0) {
                free(free);
            }
        }

     private int free(int max) {
            int numFreed = 0;
            for (; numFreed < max; numFreed++) {
                Entry<T> entry = queue.poll();
                if (entry != null) {
                    freeEntry(entry);
                } else {
                    // all cleared
                    return numFreed;
                }
            }
            return numFreed;
        }