登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›Netty源码—7.ByteBuf原理二

Netty源码—7.ByteBuf原理二

鸳剿 4 天前
大纲
9.Netty的内存规格
10.缓存数据结构
11.命中缓存的分配流程
12.Netty里有关内存分配的重要概念
13.Page级别的内存分配
14.SubPage级别的内存分配
15.ByteBuf的回收
 
9.Netty的内存规格
(1)4种内存规格
(2)内存申请单位
 
(1)4种内存规格
一.tiny：表示从0到512字节之间的内存大小
二.small：表示从512字节到8K范围的内存大小
三.normal：表示从8K到16M范围的内存大小
四.huge：表示大于16M的内存大小
 
(2)内存申请单位
Netty里所有的内存申请都是以Chunk为单位向操作系统申请的，后续所有的内存分配都是在这个Chunk里进行对应的操作。比如要分配1M的内存，那么首先要申请一个16M的Chunk，然后在这个16M的Chunk里取出一段1M的连续内存放入到Netty的ByteBuf里。
 
注意：一个Chunk的大小为16M，一个Page的大小为8K，一个SubPage的大小是0～8K，一个Chunk可以分成2048个Page。
1.png
 
10.缓存数据结构
(1)MemoryRegionCache的组成
(2)MemoryRegionCache的类型
(3)MemoryRegionCache的源码
 
(1)MemoryRegionCache的组成
Netty中与缓存相关的数据结构叫MemoryRegionCache，这是内存相关的一个缓存。MemoryRegionCache由三部分组成：queue、sizeClass、size。
 
一.queue
queue是一个队列，里面的每个元素都是MemoryRegionCache内部类Entry的一个实体，每一个Entry实体里都有一个chunk和一个handle。Netty里所有的内存都是以Chunk为单位进行分配的，而每一个handle都指向唯一一段连续的内存。所以一个chunk + 一个指向连续内存的handle，就能确定这块Entry的内存大小和内存位置，然后所有这些Entry组合起来就变成一个缓存的链。
 
二.sizeClass
sizeClass是Netty里的内存规格，其中有三种类型的内存规则。一种是tiny(0~512B)，一种是small(512B~8K)，一种是normal(8K~16M)。由于huge是直接使用非缓存的内存分配，所以不在该sizeClass范围内。
 
三.size
一个MemoryRegionCache所缓存的一个ByteBuf的大小是固定的。如果MemoryRegionCache里缓存了1K的ByteBuf，那么queue里所有的元素都是1K的ByteBuf。也就是说，同一个MemoryRegionCache它的queue里的所有元素都是固定大小的。这些固定大小分别有：tiny类型规则的是16B的整数倍直到498B，small类型规则的有512B、1K、2K、4K，normal类型规定的有8K、16K、32K。所以对于32K以上是不缓存的。
 
(2)MemoryRegionCache的类型
Netty里所有规格的MemoryRegionCache如下图示，下面的每个节点就相当于一个MemoryRegionCache的数据结构。
2.png
其中tiny类型的内存规格有32种，也就是32个节点，分别是16B、32B、48B、......、496B。这里面的每个节点都是一个MemoryRegionCache，每个MemoryRegionCache里都有一个queue。假设要分配一个16B的ByteBuf：首先会定位到small类型的内存规格里的第二个节点，然后从该节点维护的queue队列里取出一个Entry元素。通过该Entry元素可以拿到它属于哪一个chunk以及哪一个handle，从而进行内存划分。
 
small类型的内存规格有4种，也就是4个节点，分别是512B、1K、2K、4K。每个节点都是一个MemoryRegionCache，每个MemoryRegionCache里都有一个queue。假设要分配一个1K的ByteBuf：首先会定位到small类型的内存规格里的第二个节点，然后从该节点维护的queue里取出一个Entry元素。这样就可以基于这个Entry元素分配出1K内存的ByteBuf，不需要再去Chunk上找一段临时内存了。
 
normal类型的内存规格有3种，也就是3个节点，分别是8K、16K、32K，关于Normal大小的ByteBuf的内存分配也是同样道理。
 
(3)MemoryRegionCache的源码
每个线程都会有一个PoolThreadCache对象，每个PoolThreadCache对象都会有tiny、small、normal三种规格的缓存。每种规格又分heap和direct，所以每个PoolThreadCache对象会有6种缓存。PoolThreadCache类正是使用了6个MemoryRegionCache数组来维护这6种缓存。如：
 
数组tinySubPageHeapCaches拥有32个MemoryRegionCache元素，下标为n的元素用于缓存大小为n * 16B的ByteBuf。
 
数组smallSubPageHeapCaches拥有4个MemoryRegionCache元素，下标为n的元素用于缓存大小为2^n * 512B的ByteBuf。
 
数组normalHeapCaches拥有3个MemoryRegionCache元素，下标为n的元素用于缓存大小为2^n * 8K的ByteBuf。
 
数组tinySubPageHeapCaches里的每个MemoryRegionCache元素，最多可以缓存tinyCacheSize个即512个ByteBuf。
 
数组smallSubPageHeapCaches里的每个MemoryRegionCache元素，最多可以缓存smallCacheSize个即256个ByteBuf。
 
数组normalHeapCaches里的每个MemoryRegionCache元素，最多可以缓存normalCacheSize个即64个ByteBuf。
  1. final class PoolThreadCache {
  2.     //真正要分配的内存其实就是byte[] 或者 ByteBuffer，所以实际的分配就是得到一个数值handle进行定位
  3.     final PoolArena<byte[]> heapArena;
  4.     final PoolArena<ByteBuffer> directArena;
  6.     //Hold the caches for the different size classes, which are tiny, small and normal.
  7.     //有32个MemoryRegionCache元素，分别存放16B、32B、48B、...、480B、496B的SubPage级别的内存
  8.     private final MemoryRegionCache<byte[]>[] tinySubPageHeapCaches;
  9.     //有4个MemoryRegionCache元素，分别存放512B、1K、2K、4K的SubPage级别的内存
  10.     private final MemoryRegionCache<byte[]>[] smallSubPageHeapCaches;
  11.     //有3个MemoryRegionCache元素，分别存放8K、16K、32K的Page级别的内存
  12.     private final MemoryRegionCache<byte[]>[] normalHeapCaches;
  13.     private final MemoryRegionCache<ByteBuffer>[] tinySubPageDirectCaches;
  14.     private final MemoryRegionCache<ByteBuffer>[] smallSubPageDirectCaches;
  15.     private final MemoryRegionCache<ByteBuffer>[] normalDirectCaches;
  16.    
  17.     PoolThreadCache(PoolArena<byte[]> heapArena, PoolArena<ByteBuffer> directArena,
  18.             int tinyCacheSize, int smallCacheSize, int normalCacheSize,
  19.             int maxCachedBufferCapacity, int freeSweepAllocationThreshold) {
  20.         ...
  21.         this.freeSweepAllocationThreshold = freeSweepAllocationThreshold;
  22.         this.heapArena = heapArena;
  23.         this.directArena = directArena;
  24.         if (directArena != null) {
  25.             tinySubPageDirectCaches = createSubPageCaches(tinyCacheSize, PoolArena.numTinySubpagePools, SizeClass.Tiny);
  26.             smallSubPageDirectCaches = createSubPageCaches(smallCacheSize, directArena.numSmallSubpagePools, SizeClass.Small);
  27.             numShiftsNormalDirect = log2(directArena.pageSize);
  28.             normalDirectCaches = createNormalCaches(normalCacheSize, maxCachedBufferCapacity, directArena);
  29.             directArena.numThreadCaches.getAndIncrement();
  30.         } else {
  31.             //No directArea is configured so just null out all caches
  32.             tinySubPageDirectCaches = null;
  33.             smallSubPageDirectCaches = null;
  34.             normalDirectCaches = null;
  35.             numShiftsNormalDirect = -1;
  36.         }
  37.         if (heapArena != null) {
  38.             //Create the caches for the heap allocations
  39.             tinySubPageHeapCaches = createSubPageCaches(tinyCacheSize, PoolArena.numTinySubpagePools, SizeClass.Tiny);
  40.             smallSubPageHeapCaches = createSubPageCaches(smallCacheSize, heapArena.numSmallSubpagePools, SizeClass.Small);
  41.             numShiftsNormalHeap = log2(heapArena.pageSize);
  42.             normalHeapCaches = createNormalCaches(normalCacheSize, maxCachedBufferCapacity, heapArena);
  43.             heapArena.numThreadCaches.getAndIncrement();
  44.         } else {
  45.             //No heapArea is configured so just null out all caches
  46.             tinySubPageHeapCaches = null;
  47.             smallSubPageHeapCaches = null;
  48.             normalHeapCaches = null;
  49.             numShiftsNormalHeap = -1;
  50.         }
  51.         //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.
  52.         ThreadDeathWatcher.watch(thread, freeTask);
  53.     }
  54.    
  55.     private static <T> MemoryRegionCache<T>[] createSubPageCaches(int cacheSize, int numCaches, SizeClass sizeClass) {
  56.         if (cacheSize > 0) {
  57.             @SuppressWarnings("unchecked")
  58.             MemoryRegionCache<T>[] cache = new MemoryRegionCache[numCaches];
  59.             for (int i = 0; i < cache.length; i++) {
  60.                 cache[i] = new SubPageMemoryRegionCache<T>(cacheSize, sizeClass);
  61.             }
  62.             return cache;
  63.         } else {
  64.             return null;
  65.         }
  66.     }
  68.     private static <T> MemoryRegionCache<T>[] createNormalCaches(int cacheSize, int maxCachedBufferCapacity, PoolArena<T> area) {
  69.         if (cacheSize > 0) {
  70.             int max = Math.min(area.chunkSize, maxCachedBufferCapacity);
  71.             int arraySize = Math.max(1, log2(max / area.pageSize) + 1);
  73.             @SuppressWarnings("unchecked")
  74.             MemoryRegionCache<T>[] cache = new MemoryRegionCache[arraySize];
  75.             for (int i = 0; i < cache.length; i++) {
  76.                 cache[i] = new NormalMemoryRegionCache<T>(cacheSize);
  77.             }
  78.             return cache;
  79.         } else {
  80.             return null;
  81.         }
  82.     }
  83.    
  84.     private static final class SubPageMemoryRegionCache<T> extends MemoryRegionCache<T> {
  85.         SubPageMemoryRegionCache(int size, SizeClass sizeClass) {
  86.             super(size, sizeClass);
  87.         }
  88.         ...
  89.     }
  91.     private static int log2(int val) {
  92.         int res = 0;
  93.         while (val > 1) {
  94.             val >>= 1;
  95.             res++;
  96.         }
  97.         return res;
  98.     }
  99.    
  100.     ...
  101.    
  102.     private abstract static class MemoryRegionCache<T> {
  103.         private final int size;
  104.         private final Queue<Entry<T>> queue;
  105.         private final SizeClass sizeClass;
  107.         MemoryRegionCache(int size, SizeClass sizeClass) {
  108.             this.size = MathUtil.safeFindNextPositivePowerOfTwo(size);
  109.             queue = PlatformDependent.newFixedMpscQueue(this.size);
  110.             this.sizeClass = sizeClass;
  111.         }
  112.         ...
  113.         
  114.         static final class Entry<T> {
  115.             final Handle<Entry<?>> recyclerHandle;
  116.             PoolChunk<T> chunk;
  117.             long handle = -1;
  119.             Entry(Handle<Entry<?>> recyclerHandle) {
  120.                 this.recyclerHandle = recyclerHandle;
  121.             }
  123.             void recycle() {
  124.                 chunk = null;
  125.                 handle = -1;
  126.                 recyclerHandle.recycle(this);
  127.             }
  128.         }
  129.     }
  130. }
  132. abstract class PoolArena<T> implements PoolArenaMetric {
  133.     enum SizeClass {
  134.         Tiny,
  135.         Small,
  136.         Normal
  137.     }
  138.     ...
  139. }
复制代码
(3)标记连续内存的区段为未使用
标记方式会根据Page级别和SubPage级别进行标记，其中Page级别是根据二叉树来进行标记，SubPage级别是通过位图进行标记。
  1. public class PooledByteBufAllocator extends AbstractByteBufAllocator {
  2.     private final PoolThreadLocalCache threadCache;
  3.     private final PoolArena<byte[]>[] heapArenas;//一个线程会和一个PoolArena绑定
  4.     private final PoolArena<ByteBuffer>[] directArenas;//一个线程会和一个PoolArena绑定
  5.     ...
  6.     @Override
  7.     protected ByteBuf newHeapBuffer(int initialCapacity, int maxCapacity) {
  8.         PoolThreadCache cache = threadCache.get();
  9.         PoolArena<byte[]> heapArena = cache.heapArena;
  10.         ByteBuf buf;
  11.         if (heapArena != null) {
  12.             //分配堆内存
  13.             buf = heapArena.allocate(cache, initialCapacity, maxCapacity);
  14.         } else {
  15.             buf = new UnpooledHeapByteBuf(this, initialCapacity, maxCapacity);
  16.         }
  17.         return toLeakAwareBuffer(buf);
  18.     }
  20.     @Override
  21.     protected ByteBuf newDirectBuffer(int initialCapacity, int maxCapacity) {
  22.         PoolThreadCache cache = threadCache.get();
  23.         PoolArena<ByteBuffer> directArena = cache.directArena;
  24.         ByteBuf buf;
  25.         if (directArena != null) {
  26.             //分配直接内存
  27.             buf = directArena.allocate(cache, initialCapacity, maxCapacity);
  28.         } else {
  29.             if (PlatformDependent.hasUnsafe()) {
  30.                 buf = UnsafeByteBufUtil.newUnsafeDirectByteBuf(this, initialCapacity, maxCapacity);
  31.             } else {
  32.                 buf = new UnpooledDirectByteBuf(this, initialCapacity, maxCapacity);
  33.             }
  34.         }
  35.         return toLeakAwareBuffer(buf);
  36.     }
  37.     ...
  38. }
  40. abstract class PoolArena<T> implements PoolArenaMetric {
  41.     ...
  42.     PooledByteBuf<T> allocate(PoolThreadCache cache, int reqCapacity, int maxCapacity) {
  43.         PooledByteBuf<T> buf = newByteBuf(maxCapacity);//创建ByteBuf对象
  44.         allocate(cache, buf, reqCapacity);//基于PoolThreadCache对ByteBuf对象进行内存分配
  45.         return buf;
  46.     }
  47.    
  48.     private void allocate(PoolThreadCache cache, PooledByteBuf<T> buf, final int reqCapacity) {
  49.         //1.根据reqCapacity进行分段规格化
  50.         final int normCapacity = normalizeCapacity(reqCapacity);
  51.         if (isTinyOrSmall(normCapacity)) {//capacity < pageSize，需要分配的内存小于8K
  52.             int tableIdx;
  53.             PoolSubpage<T>[] table;
  54.             boolean tiny = isTiny(normCapacity);
  55.             if (tiny) {//< 512
  56.                 //2.进行缓存分配
  57.                 if (cache.allocateTiny(this, buf, reqCapacity, normCapacity)) {
  58.                     //命中缓存，was able to allocate out of the cache so move on
  59.                     return;
  60.                 }
  61.                 tableIdx = tinyIdx(normCapacity);
  62.                 table = tinySubpagePools;
  63.             } else {
  64.                 //2.进行缓存分配
  65.                 if (cache.allocateSmall(this, buf, reqCapacity, normCapacity)) {
  66.                     //命中缓存，was able to allocate out of the cache so move on
  67.                     return;
  68.                 }
  69.                 tableIdx = smallIdx(normCapacity);
  70.                 table = smallSubpagePools;
  71.             }
  73.             final PoolSubpage<T> head = table[tableIdx];
  75.             //Synchronize on the head.
  76.             //This is needed as PoolChunk#allocateSubpage(int) and PoolChunk#free(long) may modify the doubly linked list as well.
  77.             synchronized (head) {
  78.                 final PoolSubpage<T> s = head.next;
  79.                 if (s != head) {
  80.                     assert s.doNotDestroy && s.elemSize == normCapacity;
  81.                     long handle = s.allocate();
  82.                     assert handle >= 0;
  83.                     s.chunk.initBufWithSubpage(buf, handle, reqCapacity);
  84.                     if (tiny) {
  85.                         allocationsTiny.increment();
  86.                     } else {
  87.                         allocationsSmall.increment();
  88.                     }
  89.                     return;
  90.                 }
  91.             }
  92.             //没有命中缓存
  93.             allocateNormal(buf, reqCapacity, normCapacity);
  94.             return;
  95.         }
  96.         if (normCapacity <= chunkSize) {//需要分配的内存大于8K，但小于16M
  97.             //2.进行缓存分配
  98.             if (cache.allocateNormal(this, buf, reqCapacity, normCapacity)) {
  99.                 //命中缓存，was able to allocate out of the cache so move on
  100.                 return;
  101.             }
  102.             //没有命中缓存
  103.             allocateNormal(buf, reqCapacity, normCapacity);
  104.         } else {//需要分配的内存大于16M
  105.             //Huge allocations are never served via the cache so just call allocateHuge
  106.             allocateHuge(buf, reqCapacity);
  107.         }
  108.     }
  109.    
  110.     //根据reqCapacity进行分段规格化
  111.     int normalizeCapacity(int reqCapacity) {
  112.         if (reqCapacity < 0) {
  113.             throw new IllegalArgumentException("capacity: " + reqCapacity + " (expected: 0+)");
  114.         }
  115.         if (reqCapacity >= chunkSize) {
  116.             return reqCapacity;
  117.         }
  118.         if (!isTiny(reqCapacity)) { // >= 512
  119.             int normalizedCapacity = reqCapacity;
  120.             normalizedCapacity --;
  121.             normalizedCapacity |= normalizedCapacity >>>  1;
  122.             normalizedCapacity |= normalizedCapacity >>>  2;
  123.             normalizedCapacity |= normalizedCapacity >>>  4;
  124.             normalizedCapacity |= normalizedCapacity >>>  8;
  125.             normalizedCapacity |= normalizedCapacity >>> 16;
  126.             normalizedCapacity ++;
  127.             if (normalizedCapacity < 0) {
  128.                 normalizedCapacity >>>= 1;
  129.             }
  130.             return normalizedCapacity;
  131.         }
  132.         if ((reqCapacity & 15) == 0) {
  133.             return reqCapacity;
  134.         }
  135.         return (reqCapacity & ~15) + 16;
  136.     }
  137.     ...
  138. }
  140. final class PoolThreadCache {
  141.     final PoolArena<byte[]> heapArena;
  142.     final PoolArena<ByteBuffer> directArena;
  144.     //Hold the caches for the different size classes, which are tiny, small and normal.
  145.     //有32个MemoryRegionCache元素，分别存放16B、32B、48B、...、480B、496B的SubPage级别的内存
  146.     private final MemoryRegionCache<byte[]>[] tinySubPageHeapCaches;
  147.     //有4个MemoryRegionCache元素，分别存放512B、1K、2K、4K的SubPage级别的内存
  148.     private final MemoryRegionCache<byte[]>[] smallSubPageHeapCaches;
  149.     //有3个MemoryRegionCache元素，分别存放8K、16K、32K的Page级别的内存
  150.     private final MemoryRegionCache<byte[]>[] normalHeapCaches;
  151.     private final MemoryRegionCache<ByteBuffer>[] tinySubPageDirectCaches;
  152.     private final MemoryRegionCache<ByteBuffer>[] smallSubPageDirectCaches;
  153.     private final MemoryRegionCache<ByteBuffer>[] normalDirectCaches;
  154.     ...
  155.    
  156.     //Try to allocate a tiny buffer out of the cache. Returns true if successful false otherwise
  157.     boolean allocateTiny(PoolArena<?> area, PooledByteBuf<?> buf, int reqCapacity, int normCapacity) {
  158.         //首先调用cacheForTiny()方法找到需要分配的size对应的MemoryRegionCache
  159.         //然后调用allocate()方法基于MemoryRegionCache去给ByteBuf对象分配内存
  160.         return allocate(cacheForTiny(area, normCapacity), buf, reqCapacity);
  161.     }
  162.    
  163.     //找到需要分配的size对应的MemoryRegionCache
  164.     private MemoryRegionCache<?> cacheForTiny(PoolArena<?> area, int normCapacity) {
  165.         int idx = PoolArena.tinyIdx(normCapacity);
  166.         if (area.isDirect()) {
  167.             return cache(tinySubPageDirectCaches, idx);
  168.         }
  169.         return cache(tinySubPageHeapCaches, idx);
  170.     }
  171.    
  172.     //根据索引去缓存数组中返回一个MemoryRegionCache元素
  173.     private static <T> MemoryRegionCache<T> cache(MemoryRegionCache<T>[] cache, int idx) {
  174.         if (cache == null || idx > cache.length - 1) {
  175.             return null;
  176.         }
  177.         return cache[idx];
  178.     }
  179.    
  180.     //基于MemoryRegionCache去给ByteBuf对象分配内存
  181.     private boolean allocate(MemoryRegionCache<?> cache, PooledByteBuf buf, int reqCapacity) {
  182.         if (cache == null) {
  183.             return false;
  184.         }
  185.         //调用MemoryRegionCache的allocate()方法给buf分配大小为reqCapacity的一块内存
  186.         boolean allocated = cache.allocate(buf, reqCapacity);
  187.         if (++ allocations >= freeSweepAllocationThreshold) {
  188.             allocations = 0;
  189.             trim();
  190.         }
  191.         return allocated;
  192.     }
  193.     ...
  194.     private abstract static class MemoryRegionCache<T> {
  195.         private final int size;
  196.         private final Queue<Entry<T>> queue;
  197.         private final SizeClass sizeClass;
  198.         private int allocations;
  199.         ...
  200.         //Allocate something out of the cache if possible and remove the entry from the cache.
  201.         public final boolean allocate(PooledByteBuf<T> buf, int reqCapacity) {
  202.             //步骤一：从queue队列中弹出一个Entry元素
  203.             Entry<T> entry = queue.poll();
  204.             if (entry == null) {
  205.                 return false;
  206.             }
  207.             //步骤二：初始化buf
  208.             initBuf(entry.chunk, entry.handle, buf, reqCapacity);
  209.             //步骤三：将弹出的Entry元素放入对象池中进行复用
  210.             entry.recycle();
  212.             //allocations is not thread-safe which is fine as this is only called from the same thread all time.
  213.             ++ allocations;
  214.             return true;
  215.         }
  216.      
  217.         //Init the PooledByteBuf using the provided chunk and handle with the capacity restrictions.
  218.         protected abstract void initBuf(PoolChunk<T> chunk, long handle, PooledByteBuf<T> buf, int reqCapacity);
  219.       
  220.         static final class Entry<T> {
  221.             final Handle<Entry<?>> recyclerHandle;
  222.             PoolChunk<T> chunk;
  223.             long handle = -1;
  225.             Entry(Handle<Entry<?>> recyclerHandle) {
  226.                 this.recyclerHandle = recyclerHandle;
  227.             }
  229.             void recycle() {
  230.                 chunk = null;
  231.                 handle = -1;
  232.                 recyclerHandle.recycle(this);
  233.             }
  234.         }
  235.     }
  236. }
复制代码
(4)将ByteBuf对象添加到对象池
一开始时，对象池是没有PooledByteBuf对象的，当PooledByteBuf对象被释放时不会被立即销毁，而是会加入到对象池里。
 
这样当Netty每次去拿一个PooledByteBuf对象时，就可以先从对象池里获取，取出对象之后就可以进行内存分配以及初始化了。
 
考虑到PooledByteBuf对象会经常被申请和释放，如果QPS非常高，可能会产生很多PooledByteBuf对象，而且频繁创建和释放PooledByteBuf对象也会比较耗费资源和降低性能。
 
所以Netty便使用了对象池来减少GC：当申请PooledByteBuf对象时，就可以尽可能从对象池里去取。当释放PooledByteBuf对象时，则可以将对象添加到对象池，从而实现对象复用。
  1. final class PoolThreadCache {
  2.     final PoolArena<byte[]> heapArena;
  3.     final PoolArena<ByteBuffer> directArena;
  5.     //Hold the caches for the different size classes, which are tiny, small and normal.
  6.     //有32个MemoryRegionCache元素，分别存放16B、32B、48B、...、480B、496B的SubPage级别的内存
  7.     private final MemoryRegionCache<byte[]>[] tinySubPageHeapCaches;
  8.     //有4个MemoryRegionCache元素，分别存放512B、1K、2K、4K的SubPage级别的内存
  9.     private final MemoryRegionCache<byte[]>[] smallSubPageHeapCaches;
  10.     //有3个MemoryRegionCache元素，分别存放8K、16K、32K的Page级别的内存
  11.     private final MemoryRegionCache<byte[]>[] normalHeapCaches;
  12.     private final MemoryRegionCache<ByteBuffer>[] tinySubPageDirectCaches;
  13.     private final MemoryRegionCache<ByteBuffer>[] smallSubPageDirectCaches;
  14.     private final MemoryRegionCache<ByteBuffer>[] normalDirectCaches;
  15.     ...
  16. }
复制代码
 

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
鸳剿
4 天前

0

粉丝关注

15

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫