当前位置： 首页 > news >正文

网站怎么做认证免费网站备案号码

news 2025/10/25 17:26:21
网站怎么做认证,免费网站备案号码,平台推广方案,设计拓者吧官网Netty 的内存池设计借鉴了 jemalloc 的思想，通过多线程缓存（PoolThreadCache）、内存区域（PoolArena）、内存块（PoolChunk）、子页（PoolSubpage）以及内存块列表（…

Netty 的内存池设计借鉴了 jemalloc 的思想，通过多线程缓存（PoolThreadCache）、内存区域（PoolArena）、内存块（PoolChunk）、子页（PoolSubpage）以及内存块列表（PoolChunkList）等组件协同工作，实现了精细化和高效的内存管理。

整体架构关系图

PoolArena (内存管理域)
├── PoolChunkList[] (chunk使用率分组)
│   ├── PoolChunkList(0-25%)
│   ├── PoolChunkList(1-50%) 
│   ├── PoolChunkList(25-75%)
│   ├── PoolChunkList(50-100%)
│   ├── PoolChunkList(75-100%)
│   └── PoolChunkList(100%)
│       └── PoolChunk[] (16MB内存块)
│           ├── runs[] (大块内存分配)
│           └── PoolSubpage[] (小块内存分配)
└── PoolThreadCache (线程本地缓存)├── SmallSubPageCaches[]├── NormalCaches[]

四个核心组件（ PoolThreadCache , PoolArena , PoolChunkList , PoolChunk ，以及由 PoolChunk 派生的 PoolSubpage ）紧密协作，形成了一个完整的三级内存管理体系：

  • PoolThreadCache ：作为最顶层，提供线程本地的快速缓存，是性能优化的关键，极大地减少了锁竞争。
  • PoolArena ：作为中间的协调者，负责执行分配策略，并协调 PoolChunkList 、 PoolChunk 和 PoolSubpage 的工作。
  • PoolChunkList ：辅助 PoolArena ，通过智能分组管理 PoolChunk ，优化了 Chunk 的选择和重用。
  • PoolChunk 和 PoolSubpage ：作为最底层，直接管理物理内存， PoolChunk 负责大块内存的分配和通过伙伴算法管理， PoolSubpage 则在 PoolChunk 的基础上对小块内存进行精细化管理。

设计亮点

  • 层级隔离 ：

    • PoolThreadCache (线程级) -> PoolArena (Arena级) -> PoolChunk / PoolSubpage (Chunk/Subpage级) 的三级结构，平衡了全局管理和局部效率。

  • 多层次缓存策略 ：

    • 线程级 ： PoolThreadCache 避免锁竞争。

    • Arena级 ： PoolChunkList 按使用率对 PoolChunk 进行分组管理。

    • Chunk级 ：提供 run (用于较大内存) 和 subpage (用于较小内存) 两种分配方式。

  • 碎片管理优化 ：

    • 使用率分组 ( PoolChunkList )：避免在高使用率的 Chunk 中分配，优先选择合适的 Chunk 。

    • 伙伴算法 ( PoolChunk )：管理和合并内存块，减少外部碎片。

    • 连续合并 ：释放内存时，自动合并相邻的空闲 run。

    • 偏移排序 ：在 PoolSubpage 中，优先使用低偏移量的内存单元，有助于减少碎片。

性能优化机制 ：

  • 无锁优化 ( PoolThreadCache )：通过线程局部存储避免多线程竞争。

  • 紧凑编码/位操作编码 ：使用 long 类型的 handle 来压缩存储元数据（如 Chunk 内偏移量、 Subpage 索引等），降低了内存开销并能高效编解码。

  • 优先队列 ：可能用于快速查找合适大小的 run 。

通过这种分层设计和多种优化机制，Netty 实现了高性能、低碎片、线程安全的内存池管理。这使得 Netty 能够在高并发的网络编程场景下，依然保持较低的内存分配延迟和较高的内存利用率，有效解决了频繁内存分配带来的性能瓶颈。

 PoolThreadCache - 线程本地缓存

更详细的分析见：

PoolThreadCache 类的结构和源码实现-CSDN博客

揭秘Netty高性能线程本地存储机制：FastThreadLocal-CSDN博客

PoolThreadCache 是每个线程私有的缓存，用于缓存少量最近释放的 PooledByteBuf。这样，当线程再次请求相同大小的内存时，可以直接从缓存中获取，避免了向 PoolArena 申请内存的开销以及潜在的锁竞争。

结构:

  • 持有 PoolArena<byte[]> (堆内存区域) 和 PoolArena<ByteBuffer> (直接内存区域) 的引用。
  • 内部维护了不同大小规格的内存区域缓存 (MemoryRegionCache)，分为 smallSubPageHeapCaches, smallSubPageDirectCaches, normalHeapCaches, normalDirectCaches。这些缓存分别用于缓存不同大小 (Small/Normal) 和类型 (Heap/Direct) 的内存。
  • MemoryRegionCache 内部使用队列 (Queue<Entry<T>>) 来存储缓存的内存块信息 (Entry 包含 PoolChunk、handle 等)。
  • freeSweepAllocationThreshold: 一个阈值，当分配次数达到该阈值时，会触发 trim() 操作，清理不常用的缓存。
  • allocations: 记录当前线程缓存的分配次数。

交互:

  • 当分配内存时，首先尝试从 PoolThreadCache 中获取。
  • 如果缓存未命中，则会向 PoolArena 申请。
  • 当 PooledByteBuf 被释放时，如果其大小和类型适合缓存，并且缓存未满，则会尝试将其放入 PoolThreadCache。

优化机制:

  • 预分配: 避免频繁的arena竞争
  • 大小分层: 精确匹配减少内存浪费
  • free()时优先缓存到线程本地。
  • 超过freeSweepAllocationThreshold时触发全局释放。
// ... existing code ...
final class PoolThreadCache {private static final InternalLogger logger = InternalLoggerFactory.getInstance(PoolThreadCache.class);private static final int INTEGER_SIZE_MINUS_ONE = Integer.SIZE - 1;final PoolArena<byte[]> heapArena;final PoolArena<ByteBuffer> directArena;// Hold the caches for the different size classes, which are small and normal.private final MemoryRegionCache<byte[]>[] smallSubPageHeapCaches;private final MemoryRegionCache<ByteBuffer>[] smallSubPageDirectCaches;private final MemoryRegionCache<byte[]>[] normalHeapCaches;private final MemoryRegionCache<ByteBuffer>[] normalDirectCaches;private final int freeSweepAllocationThreshold;private final AtomicBoolean freed = new AtomicBoolean();@SuppressWarnings("unused") // Field is only here for the finalizer.private final FreeOnFinalize freeOnFinalize;private int allocations;// TODO: Test if adding padding helps under contention//private long pad0, pad1, pad2, pad3, pad4, pad5, pad6, pad7;PoolThreadCache(PoolArena<byte[]> heapArena, PoolArena<ByteBuffer> directArena,int smallCacheSize, int normalCacheSize, int maxCachedBufferCapacity,int freeSweepAllocationThreshold, boolean useFinalizer) {checkPositiveOrZero(maxCachedBufferCapacity, "maxCachedBufferCapacity");this.freeSweepAllocationThreshold = freeSweepAllocationThreshold;this.heapArena = heapArena;this.directArena = directArena;if (directArena != null) {smallSubPageDirectCaches = createSubPageCaches(smallCacheSize, directArena.sizeClass.nSubpages);normalDirectCaches = createNormalCaches(normalCacheSize, maxCachedBufferCapacity, directArena);directArena.numThreadCaches.getAndIncrement();} else {// No directArea is configured so just null out all cachessmallSubPageDirectCaches = null;normalDirectCaches = null;}if (heapArena != null) {// Create the caches for the heap allocationssmallSubPageHeapCaches = createSubPageCaches(smallCacheSize, heapArena.sizeClass.nSubpages);normalHeapCaches = createNormalCaches(normalCacheSize, maxCachedBufferCapacity, heapArena);heapArena.numThreadCaches.getAndIncrement();} else {// No heapArea is configured so just null out all cachessmallSubPageHeapCaches = null;normalHeapCaches = null;}// Only check if there are caches in use.if ((smallSubPageDirectCaches != null || normalDirectCaches != null|| smallSubPageHeapCaches != null || normalHeapCaches != null)&& freeSweepAllocationThreshold < 1) {throw new IllegalArgumentException("freeSweepAllocationThreshold: "+ freeSweepAllocationThreshold + " (expected: > 0)");}freeOnFinalize = useFinalizer ? new FreeOnFinalize(this) : null;}// ... existing code ...private abstract static class MemoryRegionCache<T> {private final int size;private final Queue<Entry<T>> queue;private final SizeClass sizeClass;private int allocations;MemoryRegionCache(int size, SizeClass sizeClass) {this.size = MathUtil.safeFindNextPositivePowerOfTwo(size);queue = PlatformDependent.newFixedMpscUnpaddedQueue(this.size);this.sizeClass = sizeClass;}// ... existing code ...static final class Entry<T> {final EnhancedHandle<Entry<?>> recyclerHandle;PoolChunk<T> chunk;ByteBuffer nioBuffer;long handle = -1;int normCapacity;Entry(Handle<Entry<?>> recyclerHandle) {this.recyclerHandle = (EnhancedHandle<Entry<?>>) recyclerHandle;}// ... existing code ...}// ... existing code ...}// ... existing code ...
}

PoolArena - 内存管理域

职责: 内存分配入口，作为内存分配的顶层管理器，协调所有内存分配策略

PoolArena 是内存分配的核心。它管理着一组 PoolChunk，并负责从这些 PoolChunk 中分配内存。通常会有多个 PoolArena (例如，CPU核心数个) 来减少线程间的竞争。PooledByteBufAllocator 会选择一个负载最小的 PoolArena 来服务当前线程。

结构:

  • parent: 指向 PooledByteBufAllocator。
  • sizeClass: 定义了不同大小内存块的规格 (SizeClasses)。
  • smallSubpagePools: PoolSubpage 的数组，用于管理不同大小规格的 Small 类型分配。每个元素是一个 PoolSubpage 链表的头节点。
  • 维护6个PoolChunkList链表（qInit/q000/q025/q050/q075/q100），按Chunk利用率分组。
  • numThreadCaches: 原子计数器，记录有多少 PoolThreadCache 正在使用此 Arena。
  • allocationsNormal, allocationsSmall, allocationsHuge: 记录不同类型的分配次数。
  • DirectArena 和 HeapArena 是其两个具体实现，分别用于分配直接内存和堆内存。

交互:

  • PoolThreadCache 在缓存未命中时会向其关联的 PoolArena 请求内存。
  • PoolArena 会根据请求的大小，从合适的 PoolChunkList 中选择一个 PoolChunk 进行分配。
  • 如果所有 PoolChunk 都不足以满足请求，PoolArena 会创建一个新的 PoolChunk。
  • 管理 PoolSubpage 的生命周期，用于 Small 类型的分配。

分配策略：

  • ​​Small请求​​（<8KB）：转交PoolSubpage处理。
  • ​​Normal请求​​（8KB-16MB）：在PoolChunkList链表中查找合适Chunk。
  • ​​Huge请求​​（>16MB）：直接分配非池化内存。
  • 线程安全：通过ReentrantLock控制并发分配。

关键属性:

// ... existing code ...
abstract class PoolArena<T> implements PoolArenaMetric {private static final boolean HAS_UNSAFE = PlatformDependent.hasUnsafe();enum SizeClass {Small,Normal}final PooledByteBufAllocator parent;final PoolSubpage<T>[] smallSubpagePools;private final PoolChunkList<T> q050;private final PoolChunkList<T> q025;private final PoolChunkList<T> q000;private final PoolChunkList<T> qInit;private final PoolChunkList<T> q075;private final PoolChunkList<T> q100;private final List<PoolChunkListMetric> chunkListMetrics;// Metrics for allocations and deallocationsprivate long allocationsNormal;// We need to use the LongCounter here as this is not guarded via synchronized block.private final LongAdder allocationsSmall = new LongAdder();private final LongAdder allocationsHuge = new LongAdder();
// ... existing code ...protected PoolArena(PooledByteBufAllocator parent, SizeClasses sizeClass) {assert null != sizeClass;this.parent = parent;this.sizeClass = sizeClass;smallSubpagePools = newSubpagePoolArray(sizeClass.nSubpages);for (int i = 0; i < smallSubpagePools.length; i ++) {smallSubpagePools[i] = newSubpagePoolHead(i);}// ... existing code ...}
// ... existing code ...static final class DirectArena extends PoolArena<ByteBuffer> {DirectArena(PooledByteBufAllocator parent, SizeClasses sizeClass) {super(parent, sizeClass);}@Overrideboolean isDirect() {
// ... existing code ...}// ... existing code ...static final class HeapArena extends PoolArena<byte[]> {private final AtomicReference<PoolChunk<byte[]>> lastDestroyedChunk;HeapArena(PooledByteBufAllocator parent, SizeClasses sizeClass) {super(parent, sizeClass);lastDestroyedChunk = new AtomicReference<>();}private static byte[] newByteArray(int size) {
// ... existing code ...}
// ... existing code ...
}

分配策略:

  • Small分配 (< 512B): 优先从PoolThreadCache获取，否则从smallSubpagePools分配
  • Normal分配 (512B - 16MB): 按使用率从低到高遍历PoolChunkList
  • Huge分配 (> 16MB): 直接创建unpooled chunk

    PoolChunk - 16MB内存块

    内存组织: 通过handle编码实现精确管理

    PoolChunk 代表一个较大的连续内存块 (默认 16MB)。它是内存分配的基本单元。一个 PoolChunk 可以被划分为多个页 (Page, 默认 8KB)。

    结构:

    • arena: 指向所属的 PoolArena。
    • memory: 实际的内存区域 (byte[] 或 ByteBuffer)。
    • unpooled:标记是否为非池化的 Chunk。
    • subpages: PoolSubpage 数组，用于管理此 Chunk 内的 Subpage 分配。数组的索引对应 Page 的索引。
    • pageSize: 页大小。
    • pageShifts: 页大小的对数。
    • chunkSize: Chunk 的总大小。
    • freeBytes: 当前 Chunk 中剩余的空闲字节数。
    • runsAvailMap, runsAvail: 用于管理和查找空闲的连续页 (Run)。runsAvailMap 使用 LongLongHashMap 存储 run 的偏移量和句柄（runOffset --> handle），runsAvail 是一个 IntPriorityQueue 数组，按 run 的大小组织。
    • handle: 一个 long 型数值，编码了内存分配的信息，如偏移量、大小、是否已使用、是否为 Subpage 等。

    交互:

    • 由 PoolArena 创建和管理。
    • 负责实际的内存分配逻辑，包括 Normal 类型的分配 (分配一个或多个连续的 Page) 和 Small 类型的分配 (从 PoolSubpage 分配)。
    • 当一个 PoolChunk 的内存被完全分配或大部分分配后，它会在 PoolArena 的不同 PoolChunkList 之间移动。

    Handle编码结构:

    // 64位handle布局
// oooooooo ooooooos ssssssss ssssssue bbbbbbbb bbbbbbbb bbbbbbbb bbbbbbbb
// o: runOffset(15bit) | s: pages(15bit) | u: isUsed(1bit) 
// e: isSubpage(1bit) | b: bitmapIdx(32bit)

    分配机制:

    • Run分配: 通过runsAvail[]优先队列管理，按offset排序减少碎片
    • Subpage分配: 小内存通过位图管理，支持高效的slot分配
    • allocateRun()：处理标准内存请求，使用伙伴算法拆分/合并空闲页。
    • allocateSubpage()：处理小对象请求，委托给PoolSubpage。
    // ... existing code ...
final class PoolChunk<T> implements PoolChunkMetric {private static final int SIZE_BIT_LENGTH = 15;private static final int INUSED_BIT_LENGTH = 1;private static final int SUBPAGE_BIT_LENGTH = 1;private static final int BITMAP_IDX_BIT_LENGTH = 32;static final int IS_SUBPAGE_SHIFT = BITMAP_IDX_BIT_LENGTH;static final int IS_USED_SHIFT = SUBPAGE_BIT_LENGTH + IS_SUBPAGE_SHIFT;static final int SIZE_SHIFT = INUSED_BIT_LENGTH + IS_USED_SHIFT;static final int RUN_OFFSET_SHIFT = SIZE_BIT_LENGTH + SIZE_SHIFT;final PoolArena<T> arena;final CleanableDirectBuffer cleanable;final Object base;final T memory;final boolean unpooled;/*** store the first page and last page of each avail run*/private final LongLongHashMap runsAvailMap;/*** manage all avail runs*/private final IntPriorityQueue[] runsAvail;private final ReentrantLock runsAvailLock;/*** manage all subpages in this chunk*/private final PoolSubpage<T>[] subpages;/*** Accounting of pinned memory – memory that is currently in use by ByteBuf instances.*/private final LongAdder pinnedBytes = new LongAdder();final int pageSize;final int pageShifts;final int chunkSize;final int maxPageIdx;// Use as cache for ByteBuffer created from the memory. These are just duplicates and so are only a container
// ... existing code ...@SuppressWarnings("unchecked")PoolChunk(PoolArena<T> arena, CleanableDirectBuffer cleanable, Object base, T memory, int pageSize, int pageShifts,int chunkSize, int maxPageIdx) {unpooled = false;this.arena = arena;this.cleanable = cleanable;this.base = base;this.memory = memory;this.pageSize = pageSize;this.pageShifts = pageShifts;this.chunkSize = chunkSize;this.maxPageIdx = maxPageIdx;freeBytes = chunkSize;runsAvail = newRunsAvailqueueArray(maxPageIdx);runsAvailLock = new ReentrantLock();runsAvailMap = new LongLongHashMap(-1);subpages = new PoolSubpage[chunkSize >> pageShifts];//insert initial run, offset = 0, pages = chunkSize / pageSizeint pages = chunkSize >> pageShifts;long initHandle = (long) pages << SIZE_SHIFT;
// ... existing code ...}
// ... existing code ...
}

    PoolSubpage

    详细分析见：揭秘Netty高性能内存池：PoolSubpage核心原理-CSDN博客

    PoolSubpage 用于管理对小块内存 (Small 类型，小于 PageSize) 的分配。一个 Page 可以被划分为多个等大的 PoolSubpage 元素 (Element)。这样做可以有效减少小内存分配时的内部碎片。

    结构:

    • chunk: 指向其所属的 PoolChunk。
    • elemSize: 当前 PoolSubpage 中每个元素的大小。
    • maxNumElems: 当前 PoolSubpage 最多可以容纳的元素数量。
    • bitmap: 位图，用于标记哪些元素是空闲的，哪些已被分配。
    • nextAvail: 下一个可用元素的索引。
    • numAvail: 当前可用的元素数量。
    • prev, next: 用于将相同 elemSize 的 PoolSubpage 组织成一个双向链表，挂在 PoolArena 的 smallSubpagePools 对应索引下。

    交互:

    • 当需要分配 Small 类型的内存时，PoolArena 会查找对应 elemSize 的 PoolSubpage 链表。
    • 如果找到可用的 PoolSubpage，则从中分配一个元素。
    • 如果没有可用的 PoolSubpage，PoolChunk 会分配一个新的 Page，并将其初始化为一个 PoolSubpage，然后加入到 PoolArena 的链表中。

    // ... existing code ...
final class PoolSubpage<T> implements PoolSubpageMetric {static final PoolSubpage<?> UNAVAILABLE = null; // TODO: make this an actual sentinel value.final PoolChunk<T> chunk;private final int pageShifts;private final int runOffset;private final int pageSize;private final long[] bitmap;PoolSubpage<T> prev;PoolSubpage<T> next;boolean doNotDestroy;int elemSize;private int maxNumElems;private int bitmapLength;private int nextAvail;private int numAvail;private final int headIndex; // The index of the head of the PoolSubPage pool in the PoolArena.// TODO: Test if adding padding helps under contention//private long pad0, pad1, pad2, pad3, pad4, pad5, pad6, pad7;/** Special constructor for the head of the PoolSubpage pool. */PoolSubpage(int headIndex) {chunk = null;pageShifts = -1;runOffset = -1;elemSize = -1;pageSize = 0;bitmap = null;this.headIndex = headIndex;}PoolSubpage(PoolSubpage<T> head, PoolChunk<T> chunk, int pageShifts, int runOffset, int pageSize, int elemSize) {this.chunk = chunk;this.pageShifts = pageShifts;this.runOffset = runOffset;this.pageSize = pageSize;this.headIndex = head.headIndex;bitmap = new long[pageSize >>> 10]; // pageSize / 16 / 64init(head, elemSize);}// ... existing code ...
}

    PoolChunkList - 使用率分组管理

    详细分析见：PoolChunkList解析-CSDN博客

    设计理念: 将不同使用率的chunk分组管理，优化分配效率

    PoolChunkList 用于将 PoolChunk 根据其内存使用率组织起来。PoolArena 维护多个 PoolChunkList，分别对应不同的使用率区间。

    qInit(0-25%) → q000(1-50%) → q025(25-75%) → q050(50-100%) → q075(75-100%) → q100(100%)

    // 初始化时的关联关系
qInit.next = q000;
q000.next = q025; 
q025.next = q050;
q050.next = q075;
q075.next = q100;

    结构:

    • arena: 指向所属的 PoolArena。
    • nextList, prevList: 指向前一个和后一个 PoolChunkList，形成一个链表结构，方便 PoolChunk 在不同使用率的列表之间移动。
    • minUsage, maxUsage: 定义了此列表接受的 PoolChunk 的最小和最大使用率。
    • head: 指向列表中的第一个 PoolChunk。列表中的 PoolChunk 也是一个双向链表。

    交互:

    • 当 PoolChunk 的使用率发生变化时 (例如，分配或释放内存后)，它可能会从一个 PoolChunkList 移动到另一个更符合其当前使用率的 PoolChunkList。
    • PoolArena 在分配内存时，会按照一定的顺序（通常是从使用率较高的列表开始，如 q050, q025, q000, qInit, q075）遍历这些 PoolChunkList，尝试从中找到合适的 PoolChunk 进行分配。
    • 碎片控制：低利用率链表优先回收，避免内存滞留。

    核心机制:

    1. 晋升规则: chunk使用率超过maxUsage时移入下一级
    2. 降级规则: 使用率低于minUsage时移入上一级
    3. 分配优先级: 从q050开始向后查找，避免碎片化

    // ... existing code ...
final class PoolChunkList<T> implements PoolChunkListMetric {private static final Iterator<PoolChunkMetric> EMPTY_METRICS = Collections.emptyIterator();private final PoolArena<T> arena;private final PoolChunkList<T> nextList;private final int minUsage;private final int maxUsage;private final int maxCapacity;private PoolChunk<T> head;private final PoolChunkList<T> prevList;// TODO: Test if adding padding helps under contention//private long pad0, pad1, pad2, pad3, pad4, pad5, pad6, pad7;PoolChunkList(PoolArena<T> arena, PoolChunkList<T> nextList, int minUsage, int maxUsage, int chunkSize) {assert minUsage <= maxUsage;this.arena = arena;this.nextList = nextList;this.minUsage = minUsage;this.maxUsage = maxUsage;maxCapacity = calculateMaxCapacity(minUsage, chunkSize);if (nextList == null) {prevList = null;} else {prevList = nextList.prevList; // This is not really used but just to make it consistent.nextList.prevList = this;}}// ... existing code ...
}

    辅助组件​​

    ​​IntPriorityQueue​​：优化空闲页查找（小顶堆）。

    ​​LongLongHashMap​​：高效管理空闲页元数据（开放寻址哈希）。

    ​​SizeClasses​​：定义内存分级策略（sizeIdx→size/pageIdx→pages映射）。

    见：

    Netty PoolChunk依赖的自定义数据结构：IntPriorityQueue和LongLongHashMap -CSDN博客

    协作流程分析

    分配流程 (PoolArena.allocate())

    1. 请求进入PoolArena​​，按大小分类（Small/Normal/Huge）。
    2. ​​Small请求​​： 从PoolThreadCache获取缓存 → 失败则查smallSubpagePools链表 → 无可用页时创建新PoolSubpage。
    3. ​​Normal请求​​： 遍历PoolChunkList链表 → 在PoolChunk中分配连续页 → 更新Chunk位置。
    1. 尺寸判断与缓存查找if (size <= maxCachedBufferCapacity) {// 先查PoolThreadCacheif (cache.allocateSmall/Normal()) return;}2. Arena级分配if (sizeIdx <= smallMaxSizeIdx) {// 小内存: 从smallSubpagePools分配allocateSmall();} else if (sizeIdx < nPSizes) {// 中等内存: 遍历PoolChunkListallocateNormal();  } else {// 大内存: 直接分配unpooledallocateHuge();}

    ChunkList遍历策略

    // 关键代码 - 从q050开始分配
private void allocateNormal(PooledByteBuf<T> buf, int reqCapacity, int sizeIdx, PoolThreadCache cache) {if (q050.allocate(buf, reqCapacity, sizeIdx, cache) ||q025.allocate(buf, reqCapacity, sizeIdx, cache) ||q000.allocate(buf, reqCapacity, sizeIdx, cache) ||qInit.allocate(buf, reqCapacity, sizeIdx, cache) ||q075.allocate(buf, reqCapacity, sizeIdx, cache)) {return;}// 新建chunkPoolChunk<T> c = newChunk(pageSize, nPSizes, pageShifts, chunkSize);boolean success = c.allocate(buf, reqCapacity, sizeIdx, cache);qInit.add(c);
}

    释放与回收流程

    优先放回PoolThreadCache → 触发定期缓存清理 → 最终归还到PoolArena。

    1. 缓存回收if (cache.add(chunk, handle, normCapacity)) {// 成功加入PoolThreadCachereturn;}2. Chunk级释放  chunk.free(handle, normCapacity, nioBuffer);3. ChunkList重新分组if (chunk.freeBytes > chunk.chunkSize * maxUsage / 100) {// 移至更低使用率的ChunkListremove(chunk);nextList.add(chunk);}

    内存到底在哪里？如何复用？

    外部用户通常通过 ByteBufAllocator 接口的公共方法来请求内存，例如：

    • allocator.heapBuffer(initialCapacity, maxCapacity)
      这是请求堆内存的公共 API，它在内部会调用到 newHeapBuffer。

    • allocator.buffer(...)
      根据分配器的默认设置（是否偏好直接内存）来决定调用 heapBuffer 还是 directBuffer。


    实际的物理内存（byte[] 用于堆内存，ByteBuffer 用于直接内存）由 PoolChunk 对象持有和管理。
    一个 PoolChunk 代表一块较大的连续内存，默认大小为 ​​16MB​​。

    内存复用流程（精炼版）

    1. ​​请求内存​​
      外部调用 allocator.buffer() 或 allocator.heapBuffer() / allocator.directBuffer() 请求一个 ByteBuf。这个请求会调用到会调用到 newHeapBuffer/newDirectBuffer

    2. ​​选择 Arena​​
      PooledByteBufAllocator 内部维护了一个 PoolThreadLocalCache（通过 FastThreadLocal 实现），它为每个线程缓存了一个 PoolArena（堆内存和直接内存各一个）。分配器首先从 PoolThreadLocalCache 中获取当前线程绑定的 PoolArena。

    3. ​​线程缓存分配​​
      PoolArena 会将分配请求委托给 PoolThreadCache。
      PoolThreadCache 为不同大小的内存（Tiny/Small/Normal）维护了缓存队列（MemoryRegionCache）。它会优先尝试从这些缓存队列中直接获取一个已回收的、大小合适的 ByteBuf。若成功，分配即完成（极快）。

    4. ​​Arena 分配​​
      若线程缓存无可用 ByteBuf，则由 PoolArena 分配：

      • 管理一个或多个 PoolChunk。
      • 对 ​​Normal​​ 大小内存（>pageSize），直接在 PoolChunk 中分配。
      • 对 ​​Small/Tiny​​ 内存，先从 PoolChunk 分配一个 Page（默认8KB），再将其划分为更小的 Subpage 分配。

    5. ​​创建 ByteBuf 对象​​
      内存分配成功后，从对象池获取 PooledByteBuf 实例（如 PooledHeapByteBuf 或 PooledDirectByteBuf），包装内存块的元信息（句柄、偏移量、长度等），最终返回该对象。

    6. ​​释放内存​​
      调用 ByteBuf.release() 方法。

    7. ​​回收内存​​

      • release() 将内存块交还 PoolArena 并标记为空闲。
      • PooledByteBuf 对象本身也会被回收到对象池。
      • 释放的内存块可能被缓存到 PoolThreadCache 中，供下次快速分配。

    8. ​​内存复用​​
      被标记为空闲的内存（无论在 PoolChunk 还是 PoolThreadCache 中）均可被后续分配请求复用。

    http://www.dtcms.com/a/526295.html

    相关文章：

  1. 西安网站开发的未来发展东莞企业官方网站建设
  2. 11. Python 列表： 元素增操作详解
  3. 記錄js中的冒泡事件
  4. 腾讯云 怎样建设网站域客式单页网站能申请域名吗
  5. 西双版纳州住房和城乡建设局网站wordpress注册美化
  6. 多种方法找回Root密码详细操作步骤
  7. 阿里云服务器建设网站视频网站用什么做的好
  8. 大专生工作后还能专升本吗？对职业发展有帮助吗？
  9. 棉桃剥壳机做网站重庆网站推广营销
  10. 大学生简历免费制作网站互联网备案服务平台
  11. 哪些网站用django做的狼雨seo网站排名查询
  12. 网站制作公司推荐深圳黑马品牌网站设计
  13. 做网站需要字体切换从用户旅程角度做网站分析
  14. 橙色主题手机网站希爱力副作用太强了
  15. 数字化转型：概念性名词浅谈（第八十讲）
  16. 公司注册网站模板长沙口碑好网站建设企业
  17. leetcode学习笔记3：轮转数组（多次翻转数组思想）
  18. 新手网站建设教程图书宁波企业建站程序
  19. 银川做网站建设wordpress多条件过滤
  20. 【shell】每日shell练习：系统备份文件管理/系统性能趋势分析
  21. 重庆门户网站开发报价app开发公司十强
  22. 广东建设协会网站首页关键词推广seo
  23. Orleans 配置方式时序图
  24. 网站建设 空间杭州 电子商务网站建设 网络服务
  25. 有哪些图片设计网站有哪些问题网站权重最高
  26. 怎样上传网站到百度wordpress 文章截取
  27. 网站建设120wordpress左右
  28. 如何上传网站模板如何评价一个网站设计的好坏
  29. 苏州做网站费用东莞模板建站平台
  30. 个人资质网站做推广wordpress漏洞 2014