netty源码阅读之ByteBuf之内存分配器UnpooledByteBufAllocator

我们从两个角度分析UnpooledByteBufAllocator：

1、heap内存的分配

2、direct内存的分配

由于unpooled就是自己去操作底层api去分配内存，实现起来比较简单。

一、heap内存的分配

上一篇文章其实在最后一部分我们分析过了，heap的的内存分配和读取都是在array数组上面。分配的堆内存源码就是下面UnpooledByteBufAllocator的这一段：

1. 
   
2. @Override
3. protected ByteBuf newHeapBuffer(int initialCapacity, int maxCapacity) {
4. return PlatformDependent.hasUnsafe() ? new UnpooledUnsafeHeapByteBuf(this, initialCapacity, maxCapacity)
5. : new UnpooledHeapByteBuf(this, initialCapacity, maxCapacity);
6. }

参考上一篇文章第三部分看可以了

二、direct内存的分配

和heap不同，direct内存分配放在buffer里面，然后unsafe的direct buffer是通过底层的unsafe类去操作的。（其实看源码到最终，direct的buffer都是通过unsafe去操作的）

从UnpooledByteBufAllocator分配direct内存的这个源码开始看起：

1. 
   
2. @Override
3. protected ByteBuf newDirectBuffer(int initialCapacity, int maxCapacity) {
4. ByteBuf buf = PlatformDependent.hasUnsafe() ?
5. UnsafeByteBufUtil.newUnsafeDirectByteBuf(this, initialCapacity, maxCapacity) :
6. new UnpooledDirectByteBuf(this, initialCapacity, maxCapacity);
8. return disableLeakDetector ? buf : toLeakAwareBuffer(buf);
9. }

我们先看unsafe吧，从UnsafeByteBufUtil.newUnsafeDirectByteBuf(this, initialCapacity, maxCapacity) 这里进去：

1. 
   
2. static UnpooledUnsafeDirectByteBuf newUnsafeDirectByteBuf(
3. ByteBufAllocator alloc, int initialCapacity, int maxCapacity) {
4. if (PlatformDependent.useDirectBufferNoCleaner()) {
5. return new UnpooledUnsafeNoCleanerDirectByteBuf(alloc, initialCapacity, maxCapacity);
6. }
7. return new UnpooledUnsafeDirectByteBuf(alloc, initialCapacity, maxCapacity);
8. }

不管nocleaner先，从最后UnpooledUnsafeDirectByteBuf这个函数进去：

1. 
   
2. /**
3. * Creates a new direct buffer.
4. *
5. * @param initialCapacity the initial capacity of the underlying direct buffer
6. * @param maxCapacity the maximum capacity of the underlying direct buffer
7. */
8. protected UnpooledUnsafeDirectByteBuf(ByteBufAllocator alloc, int initialCapacity, int maxCapacity) {
9. super(maxCapacity);
10. if (alloc == null) {
11. throw new NullPointerException("alloc");
12. }
13. if (initialCapacity < 0) {
14. throw new IllegalArgumentException("initialCapacity: " + initialCapacity);
15. }
16. if (maxCapacity < 0) {
17. throw new IllegalArgumentException("maxCapacity: " + maxCapacity);
18. }
19. if (initialCapacity > maxCapacity) {
20. throw new IllegalArgumentException(String.format(
21. "initialCapacity(%d) > maxCapacity(%d)", initialCapacity, maxCapacity));
22. }
24. this.alloc = alloc;
25. setByteBuffer(allocateDirect(initialCapacity), false);
26. }

最后这个allocateDirect(initialCapacity):

1. 
   
2. /**
3. * Allocate a new direct {@link ByteBuffer} with the given initialCapacity.
4. */
5. protected ByteBuffer allocateDirect(int initialCapacity) {
6. return ByteBuffer.allocateDirect(initialCapacity);
7. }

就是调用jdk底层去创建directbytebuffer。

回去setByteBuffer：

1. 
   
2. final void setByteBuffer(ByteBuffer buffer, boolean tryFree) {
3. if (tryFree) {
4. ByteBuffer oldBuffer = this.buffer;
5. if (oldBuffer != null) {
6. if (doNotFree) {
7. doNotFree = false;
8. } else {
9. freeDirect(oldBuffer);
10. }
11. }
12. }
13. this.buffer = buffer;
14. memoryAddress = PlatformDependent.directBufferAddress(buffer);
15. tmpNioBuf = null;
16. capacity = buffer.remaining();
17. }

把刚刚调用allocateDirect分配的buffer赋值到this.buffer里面去。

注意memoryAddress，从这PlatformDependent.directBufferAddress(buffer);一直进去：

1. 
   
2. static long directBufferAddress(ByteBuffer buffer) {
3. return getLong(buffer, ADDRESS_FIELD_OFFSET);
4. }

也就是，我们获取到内存地址，加上offset，就是我们能用的开始的地址，getLong继续就是：

1. 
   
2. private static long getLong(Object object, long fieldOffset) {
3. return UNSAFE.getLong(object, fieldOffset);
4. }

调用了jdk底层unsafe加上offset为我们获取我们能用的direct地址，最终回来保存到memoryAddress里面。

回到UnpooledUnsafeDirectByteBuf的_getByte方法：

1. 
   
3. @Override
4. protected byte _getByte(int index) {
5. return UnsafeByteBufUtil.getByte(addr(index));
6. }

看addr(index):

1. 
   
2. long addr(int index) {
3. return memoryAddress + index;
4. }

这个memoryAddress就是上面那个，也就是通过memoryAddress就能操作unsafedirect buffer内存了。

好，这就是UnpooledByteBufAllocator分配和操作direct unsafe内存的分析了

看非unsafe，一样是下面这个代码：

1. 
   
2. @Override
3. protected ByteBuf newDirectBuffer(int initialCapacity, int maxCapacity) {
4. ByteBuf buf = PlatformDependent.hasUnsafe() ?
5. UnsafeByteBufUtil.newUnsafeDirectByteBuf(this, initialCapacity, maxCapacity) :
6. new UnpooledDirectByteBuf(this, initialCapacity, maxCapacity);
8. return disableLeakDetector ? buf : toLeakAwareBuffer(buf);
9. }

从UnpooledDirectByteBuf进入：

1. 
   
2. private void setByteBuffer(ByteBuffer buffer) {
3. ByteBuffer oldBuffer = this.buffer;
4. if (oldBuffer != null) {
5. if (doNotFree) {
6. doNotFree = false;
7. } else {
8. freeDirect(oldBuffer);
9. }
10. }
12. this.buffer = buffer;
13. tmpNioBuf = null;
14. capacity = buffer.remaining();
15. }

可以看到没有memoryAddress了，只有buffer。在UnpooledDirectByteBuf的_getByte方法里面，就是直接读取buffer里面的内容了：

1. 
   
2. @Override
3. protected byte _getByte(int index) {
4. return buffer.get(index);
5. }