写自己的netty源码分析--ByteBuf

最新推荐文章于 2024-08-15 03:43:27 发布
最新推荐文章于 2024-08-15 03:43:27 发布
阅读量495 收藏
点赞数
分类专栏： 源码分析 走好每一步路--netty篇
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40722284/article/details/94578160
版权

绪论

三个问题

  • 内存的类别有哪些？
  • 如何减少多线程内存分配之间的竞争？
  • 不同大小的内存是如何进行分配的？

主要内容

  • 内存与内存管理器的抽象
  • 不同规格大小和不同类别的内存的分配策略
  • 内存的回收过程

ByteBuf结构与重要API

内存结构

该结构其实是一个数组，有两个索引 readerIndex 和writerIndex，支持索引访问。

*      +-------------------+------------------+------------------+
*      | discardable bytes |  readable bytes  |  writable bytes  |
*      |                   |     (CONTENT)    |                  |
*      +-------------------+------------------+------------------+
*      |                   |                  |                  |
*      0      <=      readerIndex   <=   writerIndex    <=    capacity

上述结构是在执行discardReadBytes()之前，而在执行discardReadBytes()之后结构变为：

*  AFTER discardReadBytes()
*
*      +------------------+--------------------------------------+
*      |  readable bytes  |    writable bytes (got more space)   |
*      +------------------+--------------------------------------+
*      |                  |                                      |
* readerIndex (0) <= writerIndex (decreased)        <=        capacity

在执行clear()之后变为：

*  AFTER clear()
*      +---------------------------------------------------------+
*      |             writable bytes (got more space)             |
*      +---------------------------------------------------------+
*      |                                                         |
*      0 = readerIndex = writerIndex            <=            capacity

重要API

public abstract class ByteBuf implements ReferenceCounted, Comparable<ByteBuf> {
    public abstract int capacity();
    public abstract int maxCapacity();
    public abstract boolean isDirect();

    public abstract ByteBuf readerIndex(int readerIndex); 读当前位置索引
    public abstract ByteBuf writerIndex(int writerIndex); 写当前位置索引

    public abstract ByteBuf markReaderIndex(); 标记当前读索引
    public abstract ByteBuf resetReaderIndex(); 重置到之前标记的读索引

    public abstract ByteBuf markWriterIndex(); 标记当前写索引
    public abstract ByteBuf resetWriterIndex(); 重置到之前标记的写索引
    ......
}

ByteBuf分类

  • Pooled和Unpooled
  •  Unsafe和非Unsafe
  • Heap和Direct
ByteBuf (io.netty.buffer)
    AbstractByteBuf (io.netty.buffer)
        AbstractDerivedByteBuf (io.netty.buffer)
            ReadOnlyByteBuf (io.netty.buffer)
            DuplicatedByteBuf (io.netty.buffer)
                UnpooledDuplicatedByteBuf (io.netty.buffer)
                    PooledNonRetainedDuplicateByteBuf in AbstractPooledDerivedByteBuf (io.netty.buffer)
            AbstractUnpooledSlicedByteBuf (io.netty.buffer)
                UnpooledSlicedByteBuf (io.netty.buffer)
                    PooledNonRetainedSlicedByteBuf in AbstractPooledDerivedByteBuf (io.netty.buffer)
                SlicedByteBuf (io.netty.buffer)
        AbstractReferenceCountedByteBuf (io.netty.buffer)
            AbstractPooledDerivedByteBuf (io.netty.buffer)
                PooledDuplicatedByteBuf (io.netty.buffer)
                PooledSlicedByteBuf (io.netty.buffer)
            CompositeByteBuf (io.netty.buffer)
                WrappedCompositeByteBuf (io.netty.buffer)
                    SimpleLeakAwareCompositeByteBuf (io.netty.buffer)
                        AdvancedLeakAwareCompositeByteBuf (io.netty.buffer)
            ReadOnlyByteBufferBuf (io.netty.buffer)
                ReadOnlyUnsafeDirectByteBuf (io.netty.buffer)
            UnpooledUnsafeDirectByteBuf (io.netty.buffer)
                UnpooledUnsafeNoCleanerDirectByteBuf (io.netty.buffer)
                    InstrumentedUnpooledUnsafeNoCleanerDirectByteBuf in UnpooledByteBufAllocator (io.netty.buffer)
                WrappedUnpooledUnsafeDirectByteBuf (io.netty.buffer)
                ThreadLocalUnsafeDirectByteBuf in ByteBufUtil (io.netty.buffer)
                InstrumentedUnpooledUnsafeDirectByteBuf in UnpooledByteBufAllocator (io.netty.buffer)
            FixedCompositeByteBuf (io.netty.buffer)
            PooledByteBuf (io.netty.buffer)
                PooledUnsafeDirectByteBuf (io.netty.buffer)
                PooledHeapByteBuf (io.netty.buffer)
                    PooledUnsafeHeapByteBuf (io.netty.buffer)
                PooledDirectByteBuf (io.netty.buffer)
            UnpooledDirectByteBuf (io.netty.buffer)
                ThreadLocalDirectByteBuf in ByteBufUtil (io.netty.buffer)
                InstrumentedUnpooledDirectByteBuf in UnpooledByteBufAllocator (io.netty.buffer)
            UnpooledHeapByteBuf (io.netty.buffer)
                UnpooledUnsafeHeapByteBuf (io.netty.buffer)
                    InstrumentedUnpooledUnsafeHeapByteBuf in UnpooledByteBufAllocator (io.netty.buffer)
                InstrumentedUnpooledHeapByteBuf in UnpooledByteBufAllocator (io.netty.buffer)

Pooled和Unpooled

pooled：从预先分配好的一块内存里取一段连续内存封装成ByteBuf分配给应用程序；

unpooled：内存分配时直接调用系统API直接向操作系统申请内存；

 Unsafe和非Unsafe

JDK底层有Unsafe对象，可直接拿到对象的内存地址进行一些读写操作；

非Unsafe：不依赖于JDK底层Unsafe对象；

Unsafe例子：

进入类PooledUnsafeHeapByteBuf中的_getByte()方法：
protected byte _getByte(int index) {
        return UnsafeByteBufUtil.getByte(memory, idx(index));
    }
static byte getByte(byte[] array, int index) {
        return PlatformDependent.getByte(array, index);
    }
public static byte getByte(byte[] data, int index) {
        return PlatformDependent0.getByte(data, index);
    }
static byte getByte(byte[] data, int index) {
        return UNSAFE.getByte(data, BYTE_ARRAY_BASE_OFFSET + index);
    }

 非Unsafe例子：

进入类PooledHeapByteBuf中的_getByte()方法：
protected byte _getByte(int index) {
        return HeapByteBufUtil.getByte(memory, idx(index));
    }
static byte getByte(byte[] memory, int index) {
        return memory[index];
    }

Heap和Direct

Heap：直接在heap上进行内存分配；需要由GC 管理，内存自动释放；

Direct：直接调用JDK的API进行内存分配；不受GUN控制，不会参与GC 的过程，内存需要手动释放；

heap例子：

进入类UnpooledHeapByteBuf中的_getByte()方法：
protected byte _getByte(int index) {
        return HeapByteBufUtil.getByte(array, index);
    }
static byte getByte(byte[] memory, int index) {
        return memory[index];
    }

Direct例子：

进入类UnpooledDirectByteBuf中：

private ByteBuffer buffer;
基于buffer,而ByteBuffer指定是DirectByteBuffer

进入getByte()方法：
public byte getByte(int index) {
    ensureAccessible();
    return _getByte(index);
}
protected byte _getByte(int index) {
    return buffer.get(index);
}

接下来查看buffer是如何初始化的，netty中有一个内存管理工具--Unpooled类，接下来查看一下它的源码

进入类Unpooled中的directBuffer()方法：
public static ByteBuf directBuffer(int initialCapacity, int maxCapacity) {
        return ALLOC.directBuffer(initialCapacity, maxCapacity);
    }
进入类AbstractByteBufAllocator中：
public ByteBuf directBuffer(int initialCapacity, int maxCapacity) {
        if (initialCapacity == 0 && maxCapacity == 0) {
            return emptyBuf;
        }
        validate(initialCapacity, maxCapacity);
        return newDirectBuffer(initialCapacity, maxCapacity);
    }
进入newDirectBuffer()方法：
protected ByteBuf newDirectBuffer(int initialCapacity, int maxCapacity) {
        final ByteBuf buf;
        if (PlatformDependent.hasUnsafe()) {
            buf = noCleaner ? new InstrumentedUnpooledUnsafeNoCleanerDirectByteBuf(this, initialCapacity, maxCapacity) :
                    new InstrumentedUnpooledUnsafeDirectByteBuf(this, initialCapacity, maxCapacity);
        } else {
            buf = new InstrumentedUnpooledDirectByteBuf(this, initialCapacity, maxCapacity);
        }
        return disableLeakDetector ? buf : toLeakAwareBuffer(buf);
    }
进入InstrumentedUnpooledDirectByteBuf()方法：
private static final class InstrumentedUnpooledDirectByteBuf extends UnpooledDirectByteBuf {
        InstrumentedUnpooledDirectByteBuf(
                UnpooledByteBufAllocator alloc, int initialCapacity, int maxCapacity) {
            super(alloc, initialCapacity, maxCapacity);
        }
进入super()方法：
public UnpooledDirectByteBuf(ByteBufAllocator alloc, int initialCapacity, int maxCapacity) {
        super(maxCapacity);
        if (alloc == null) {
            throw new NullPointerException("alloc");
        }
        if (initialCapacity < 0) {
            throw new IllegalArgumentException("initialCapacity: " + initialCapacity);
        }
        if (maxCapacity < 0) {
            throw new IllegalArgumentException("maxCapacity: " + maxCapacity);
        }
        if (initialCapacity > maxCapacity) {
            throw new IllegalArgumentException(String.format(
                    "initialCapacity(%d) > maxCapacity(%d)", initialCapacity, maxCapacity));
        }

        this.alloc = alloc;
        setByteBuffer(allocateDirect(initialCapacity));
    }
进入setByteBuffer()方法：
private void setByteBuffer(ByteBuffer buffer) {
        ByteBuffer oldBuffer = this.buffer; 可以看到在这里将allocateDirect分配到内存保存到底层的buffer对象
        if (oldBuffer != null) {
            if (doNotFree) {
                doNotFree = false;
            } else {
                freeDirect(oldBuffer);
            }
        }

        this.buffer = buffer;
        tmpNioBuf = null;
        capacity = buffer.remaining();
    }
进入allocateDirect()方法：
protected ByteBuffer allocateDirect(int initialCapacity) {
        return ByteBuffer.allocateDirect(initialCapacity);
    }
public static ByteBuffer allocateDirect(int capacity) {
        return new DirectByteBuffer(capacity);  最终调用了DirectByteBuffer这个API进行内存分配
    }

ByteBufAllocator分析

内存分配器

进入类AbstractByteBufAllocator中：
public ByteBuf buffer(int initialCapacity, int maxCapacity) {
        if (directByDefault) {  默认是堆外内存就分配堆外内存
            return directBuffer(initialCapacity, maxCapacity);
        }
        return heapBuffer(initialCapacity, maxCapacity);  否则分配堆内内存
    }
类AbstractByteBufAllocator通过暴露两个抽象方法实现扩展，让子类实现创建堆内和堆外内存逻辑
protected abstract ByteBuf newHeapBuffer(int initialCapacity, int maxCapacity);
protected abstract ByteBuf newDirectBuffer(int initialCapacity, int maxCapacity);

netty自动判别unsafe和非unsafe，如果JDK底层有unsafe对象，直接分配一个unsafe类型的ByteBuf，否则分配一个非unsafe类型的ByteBuf。

进入类UnpooledByteBufAllocator中：
protected ByteBuf newHeapBuffer(int initialCapacity, int maxCapacity) {
        return PlatformDependent.hasUnsafe() ?  判断能不能拿到unsafe对象，来分配相应类型的内存
                new InstrumentedUnpooledUnsafeHeapByteBuf(this, initialCapacity, maxCapacity) :
                new InstrumentedUnpooledHeapByteBuf(this, initialCapacity, maxCapacity);
    }

UnpooledByteBufAllocator分析

  • heap内存的分配
  • direct内存大分配

heap内存的分配

分析入口
protected ByteBuf newHeapBuffer(int initialCapacity, int maxCapacity) {
        return PlatformDependent.hasUnsafe() ? 以下两个类都是UnpooledByteBufAllocator类的内部包装类
                new InstrumentedUnpooledUnsafeHeapByteBuf(this, initialCapacity, maxCapacity) :
                new InstrumentedUnpooledHeapByteBuf(this, initialCapacity, maxCapacity);
    }

 InstrumentedUnpooledUnsafeHeapByteBuf类

InstrumentedUnpooledUnsafeHeapByteBuf类
InstrumentedUnpooledUnsafeHeapByteBuf(UnpooledByteBufAllocator alloc, int initialCapacity, int maxCapacity) {
            super(alloc, initialCapacity, maxCapacity);
        }
进入super()方法：
UnpooledUnsafeHeapByteBuf(ByteBufAllocator alloc, int initialCapacity, int maxCapacity) {
        super(alloc, initialCapacity, maxCapacity);
}
进入super()方法：注意此时进入的是UnpooledHeapByteBuf类的UnpooledHeapByteBuf()构造方法
public UnpooledHeapByteBuf(ByteBufAllocator alloc, int initialCapacity, int maxCapacity) {
        super(maxCapacity);

        checkNotNull(alloc, "alloc");

        if (initialCapacity > maxCapacity) {
            throw new IllegalArgumentException(String.format(
                    "initialCapacity(%d) > maxCapacity(%d)", initialCapacity, maxCapacity));
        }

        this.alloc = alloc;
        setArray(allocateArray(initialCapacity));
        setIndex(0, 0);
}
进入setArray()方法：
protected byte[] allocateArray(int initialCapacity) {
        return new byte[initialCapacity];
    }
private void setArray(byte[] initialArray) {
        array = initialArray;
        tmpNioBuf = null;
    }
进入setIndex()方法：
public ByteBuf setIndex(int readerIndex, int writerIndex) {
        if (checkBounds) {
            checkIndexBounds(readerIndex, writerIndex, capacity());
        }
        setIndex0(readerIndex, writerIndex);
        return this;
    }
final void setIndex0(int readerIndex, int writerIndex) {
        this.readerIndex = readerIndex;
        this.writerIndex = writerIndex;
    }

InstrumentedUnpooledHeapByteBuf类

InstrumentedUnpooledHeapByteBuf类
InstrumentedUnpooledHeapByteBuf(UnpooledByteBufAllocator alloc, int initialCapacity, int maxCapacity) {
            super(alloc, initialCapacity, maxCapacity);
        }
进入super()方法：此时和上面的unsafe类中的一样
public UnpooledHeapByteBuf(ByteBufAllocator alloc, int initialCapacity, int maxCapacity) {
        super(maxCapacity);

        checkNotNull(alloc, "alloc");

        if (initialCapacity > maxCapacity) {
            throw new IllegalArgumentException(String.format(
                    "initialCapacity(%d) > maxCapacity(%d)", initialCapacity, maxCapacity));
        }

        this.alloc = alloc;
        setArray(allocateArray(initialCapacity));
        setIndex(0, 0);
    }

从以上可以看出，unsafe和safe类中的构造方法一样，但是不同之处在于各自类中访问内存的方式。

InstrumentedUnpooledUnsafeHeapByteBuf类的构造方法中调用了父类UnpooledUnsafeHeapByteBuf类的构造方法，
而UnpooledUnsafeHeapByteBuf类的父类是UnpooledHeapByteBuf类
UnpooledUnsafeHeapByteBuf(ByteBufAllocator alloc, int initialCapacity, int maxCapacity) {
        super(alloc, initialCapacity, maxCapacity);
    }
在此类中_getbyte()的使用是不同的
 protected byte _getByte(int index) {
        return UnsafeByteBufUtil.getByte(array, index);
    }
static byte getByte(byte[] array, int index) {
        return PlatformDependent.getByte(array, index);
    }
public static byte getByte(byte[] data, int index) {
        return PlatformDependent0.getByte(data, index);
    }
static byte getByte(byte[] data, int index) {
        return UNSAFE.getByte(data, BYTE_ARRAY_BASE_OFFSET + index);
    }
InstrumentedUnpooledHeapByteBuf类的构造方法中调用了父类UnpooledHeapByteBuf类的构造方法
InstrumentedUnpooledHeapByteBuf(UnpooledByteBufAllocator alloc, int initialCapacity, int maxCapacity) {
            super(alloc, initialCapacity, maxCapacity);
        }
在此类中的_getbyte()方法如下：
protected byte _getByte(int index) {
        return HeapByteBufUtil.getByte(array, index);
    }
static byte getByte(byte[] memory, int index) {
        return memory[index];
    }

direct内存的分配

入口
protected ByteBuf newDirectBuffer(int initialCapacity, int maxCapacity) {
        final ByteBuf buf;
        if (PlatformDependent.hasUnsafe()) {  此时暂时不研究noCleaner的问题
            buf = noCleaner ? new InstrumentedUnpooledUnsafeNoCleanerDirectByteBuf(this, initialCapacity, maxCapacity) :
                    new InstrumentedUnpooledUnsafeDirectByteBuf(this, initialCapacity, maxCapacity);
        } else {
            buf = new InstrumentedUnpooledDirectByteBuf(this, initialCapacity, maxCapacity);
        }
        return disableLeakDetector ? buf : toLeakAwareBuffer(buf);
    }
InstrumentedUnpooledUnsafeDirectByteBuf包装类中构造方法中调用了父类UnpooledUnsafeDirectByteBuf的构造方法
UnpooledByteBufAllocator alloc, int initialCapacity, int maxCapacity) {
            super(alloc, initialCapacity, maxCapacity);
        }
public UnpooledUnsafeDirectByteBuf(ByteBufAllocator alloc, int initialCapacity, int maxCapacity) {
        super(maxCapacity);
        if (alloc == null) {
            throw new NullPointerException("alloc");
        }
        if (initialCapacity < 0) {
            throw new IllegalArgumentException("initialCapacity: " + initialCapacity);
        }
        if (maxCapacity < 0) {
            throw new IllegalArgumentException("maxCapacity: " + maxCapacity);
        }
        if (initialCapacity > maxCapacity) {
            throw new IllegalArgumentException(String.format(
                    "initialCapacity(%d) > maxCapacity(%d)", initialCapacity, maxCapacity));
        }

        this.alloc = alloc;
        setByteBuffer(allocateDirect(initialCapacity), false);
    }
进入allocateDirect()方法：
protected ByteBuffer allocateDirect(int initialCapacity) {
        return ByteBuffer.allocateDirect(initialCapacity);
    }
进入allocateDirect()方法：此时调用API新建的内存，这是unpool的性质
public static ByteBuffer allocateDirect(int capacity) {
        return new DirectByteBuffer(capacity);
    }
进入setByteBuffer()方法：  这里直接操作的是内存地址
final void setByteBuffer(ByteBuffer buffer, boolean tryFree) {
        if (tryFree) {
            ByteBuffer oldBuffer = this.buffer;
            if (oldBuffer != null) {
                if (doNotFree) {
                    doNotFree = false;
                } else {
                    freeDirect(oldBuffer);
                }
            }
        }
        this.buffer = buffer;
        memoryAddress = PlatformDependent.directBufferAddress(buffer); 内存地址
        tmpNioBuf = null;
        capacity = buffer.remaining();
    }
进入directBufferAddress()方法：
public static long directBufferAddress(ByteBuffer buffer) {
        return PlatformDependent0.directBufferAddress(buffer);
    }
static long directBufferAddress(ByteBuffer buffer) {
        return getLong(buffer, ADDRESS_FIELD_OFFSET);
    }
private static long getLong(Object object, long fieldOffset) {
        return UNSAFE.getLong(object, fieldOffset);  使用UNSAFE获取内存地址
    }
InstrumentedUnpooledDirectByteBuf类的构造方法调用了父类UnpooledDirectByteBuf类的构造方法
InstrumentedUnpooledDirectByteBuf(
                UnpooledByteBufAllocator alloc, int initialCapacity, int maxCapacity) {
            super(alloc, initialCapacity, maxCapacity);
        }
public UnpooledDirectByteBuf(ByteBufAllocator alloc, int initialCapacity, int maxCapacity) {
        super(maxCapacity);
        if (alloc == null) {
            throw new NullPointerException("alloc");
        }
        if (initialCapacity < 0) {
            throw new IllegalArgumentException("initialCapacity: " + initialCapacity);
        }
        if (maxCapacity < 0) {
            throw new IllegalArgumentException("maxCapacity: " + maxCapacity);
        }
        if (initialCapacity > maxCapacity) {
            throw new IllegalArgumentException(String.format(
                    "initialCapacity(%d) > maxCapacity(%d)", initialCapacity, maxCapacity));
        }

        this.alloc = alloc;
        setByteBuffer(allocateDirect(initialCapacity));
    }
进入allocateDirect()方法：
protected ByteBuffer allocateDirect(int initialCapacity) {
        return ByteBuffer.allocateDirect(initialCapacity);
    }
public static ByteBuffer allocateDirect(int capacity) {
        return new DirectByteBuffer(capacity); 调用API新建内存
    }
进入setByteBuffer()方法： 对API进行操作
private void setByteBuffer(ByteBuffer buffer) {
        ByteBuffer oldBuffer = this.buffer;  直接对API进行更新
        if (oldBuffer != null) {
            if (doNotFree) {
                doNotFree = false;
            } else {
                freeDirect(oldBuffer);
            }
        }

        this.buffer = buffer;
        tmpNioBuf = null;
        capacity = buffer.remaining();
    }
类UnpooledDirectByteBuf获取内存的方式
protected byte _getByte(int index) {
        return buffer.get(index);
    }
类UnpooledUnsafeDirectByteBuf获取内存的方式
protected byte _getByte(int index) {
        return UnsafeByteBufUtil.getByte(addr(index));
    }
long addr(int index) {
        return memoryAddress + index;  通过内存地址加偏移量的方式获取内存
    }
static byte getByte(long address) {
        return PlatformDependent.getByte(address);
    }
public static byte getByte(long address) {
        return PlatformDependent0.getByte(address);
    }
static byte getByte(long address) {
        return UNSAFE.getByte(address);
    }

PooledByteBufAllocator分析

  • 拿到线程局部缓存PoolThreadCache
  • 在线程局部缓存的Area上进行内存分配

 

 

 

 

 

 

 

 

 

 

灯塔先生
关注
专栏目录
Netty源码分析-概述
码农杰森
09-08 484
大家好，我是小森。前段时间我们学习了Netty框架，并完成了Netty框架主要组件的入门介绍(没有学习的小伙伴可以看这Netty框架入门)；在这个系列中围绕服务端与客户端通信的示例展开学习，对Netty的Bytebuf、ChannelHandler、ChannelPipeline、Bootstrap和EventLoop等模块进行了学习，因为是入门级别所以讲的也不是很深入。但我相信通过这个入门系列的学习你已经学会了Netty框架的使用并且会产生一些思考与问题，例如下面这些： Netty的Bootstrap
netty 大端小端_Netty 5.0源码分析-ByteBuf
weixin_42332144的博客
12-24 804
1. 概念Java NIO API自带的缓冲区类功能相当有限，没有经过优化，使用JDK的ByteBuffer操作更复杂。故而Netty的作者Trustin Lee为了实现高效率的网络传输，重新造轮子，Netty中的ByteBuf实际上就相当于JDK中的ByteBuffer，其作用是在Netty中通过Channel传输数据。2. 优势可以自定义缓冲类型；通过内置的复合缓冲类型，实现透明的零拷贝(ze...
Netty源码解析之ByteBuf简析
Lisam Blog
11-11 958
ByteBuf是什么？ 首先当前类是ByteBuf.java类，是netty缓存的抽象类。主要包含如下几个Index 0<=readerIndex<=writerIndex<=capacity 包含的方法大致如下 setXxx //设置当前index对应的值 readXxx //读...
ByteBuf 源码分析
qq_40592484的博客
05-21 420
ByteBuf 的主要类继承关系 内存分配的角度来分类 1 堆内存字节（HeapByteBuf）缓冲区 ： 内存的分配和回收的速度快，可以被JVM自动回收。 缺点是如果进行Socket的I/O读写，需要做一次额外的内存复制，将堆内存的缓冲区复制到Channel中，性能会下降。 2 直接内存（DirectByteBuf） 再堆外进行内存分配，分配和回收的速度慢一些，但是将它写入或者读取将直接在内核...
Netty技术全解析：PooledUnsafeDirectByteBuf详解
最新发布
weixin_41403490的博客
08-15 224
❃博主首页 ： 「码到三十五」 ，同名公众号 :「码到三十五」♝博主的话 ： 搬的每块砖，皆为峰峦之基；公众号搜索「码到三十五」关注这个爱发技术干货的coder，一起筑基 在Netty这个高性能的网络编程框架中，PooledUnsafeDirectByteBuf是一个关键的组件，它代表了基于内存池的、非安全的...
netty ByteBuf源码分析
summerZBH123的博客
05-10 440
    在介绍netty常用的数据缓冲类之前，建议先熟悉下java NIO当中提供的ByteBuffer类的分析，netty提供自己的缓冲类就是为了解决原生java当中ByteBuffer使用不方便的问题。这篇文章主要是分析netty当中的对ByteBuf的分析。    这篇文章从以下几个方面来介绍ByteBufByteBuf的使用，及常用接口ByteBuf 源码分析ByteBuf 相关实现类By...
Netty篇：ByteBuf部分源码分析
走在路上
05-10 269
缓冲区（Buffer）      缓冲区(Buffer)就是在内存中预留指定大小的存储空间用来对输入/输出(I/O)的数据作临时存储，这部分预留的内存空间就叫做缓冲区：      使用缓冲区可以减少实际的物理读写次数，而且缓冲区在创建时就被分配内存，这块内存区域一直被重用，可以减少动态分配和回收...
【Netty专题】源码剖析netty核心基础ByteBuf
学而不思则罔,思而不学则殆！
12-23 453
在面试的时候，当面试问到netty的时候问到：你知道jdk nio中的ByteBuffer与netty中的ByteBuf有什么区别吗？来看看面试者的基础掌握的如何！你能准确回到出来个所以然吗？ 说到jdk我先说说我身边使用jdk nio的情况； 我现在公司就有个游戏项目是jdk nio2一行一行实现的通讯架构，一直在线上运营，目前该架构单服承载最高的时候达到300...
netty-code:netty包源码-源码包
03-24
Netty 是一个高性能、异步事件驱动...通过对Netty源码的学习，开发者不仅可以掌握网络编程的最佳实践，还能深入了解Java并发编程、内存管理以及性能优化等核心技能，对提升个人技术水平和解决实际问题具有极大的帮助。
Netty源码分析----writeAndFlush
菜鸟一名
07-04 3760
（*文章基于Netty4.1.22版本） ctx.writeAndFlush相当于先调用ctx.write然后再调用ctx.flush，所以下面分析write和flush write write和flush会经过pipeline的每个outbound的Handler，之前文章分析过流程，这里不再分析。 write方法最终到达HeadContext的write方法，然后什么都没做，将请求...
Netty权威指南-Netty源码
09-30
总的来说，Netty 源码分析涉及了网络编程、并发处理、事件驱动、协议编解码等多个领域，对理解 Java 高性能网络应用开发有着重要的指导意义。通过阅读源码，我们可以更深入地了解 Netty 如何实现高效的网络通信，并...
netty（十）源码分析之ByteBuf
lz710117239的博客
08-23 512
通过对netty的API的学习，可以更加游刃有余的使用netty的相关类库 对源码的学习不仅能够从源码层面掌握netty框架，方便日后的维护，拓展和定制而且可以起到触类旁通的作用，拓展读者的知识面，提升编程技能。 当我们进行数据传输的时候，往往需要使用到缓冲区，常用的缓冲区就是JDK提供的java.nio.Buffer,它的实现类如下所示： 实际上7中数据类型（Boolean除外）都有自己的
18.Netty源码之ByteBuf 详解
qq_30635523的博客
07-28 1954
highlight: arduino-light ByteBuf 是 Netty 的数据容器，所有网络通信中字节流的传输都是通过 ByteBuf 完成的。 然而 JDK NIO 包中已经提供了类似的 ByteBuffer 类，为什么 Netty 还要去重复造轮子呢？本节课我会详细地讲解 ByteBuf。 JDK NIO的ByteBuffer 我们首先介绍下 JDK NIO 的 Byte...
Netty 内存模型分析（二）PooledByteBuf 分析
anLA_的专栏
12-06 942
前面一篇主要研究了` UnpooledByteBuf` 主要工作原理，本文主要探讨 `PooledByteBuf` 相关。 本文主要从以下几个方面梳理了PooledByteBuf： 1. `PooledByteBuf ` 构成 2. `PoolChunk` 组织形式 3. `PoolChunk` 申请大内存和小内存，以及 `PoolSubpage` 组装构成 4. 池化内存`PooledByteBuf` 分配过程及，分配完后使用原理使用研究。
IDEA执行Scala程序依赖报错 - io.netty.buffer.PooledByteBufAllocator.metric()
GYT0313
05-06 1282
IDEA 执行Scala 依赖报错： Exception in thread "main" java.lang.NoSuchMethodError: io.netty.buffer.PooledByteBufAllocator.metric()Lio/netty/buffer/PooledByteBufAllocatorMetric; at org.apache.spark.network.uti...
Netty学习之旅----ByteBuf源码解读之初探UnpooledHeapByteBuf、UnpooledDirectByteBuf
热门推荐
中间件兴趣圈
01-05 1万+
首先，我们再看一下 ByteBuf 的类设计图，从中更进一步了解ByteBuf。 ByteBuf 继承自 ReferenceCounted,引用计数，也就是说 ByteBuf 的内存回收使用的是引用计数器来实现。 UnpooledHeapByteBuf 是非池化的堆内存实现，而 UnpooledDirectByteBuf 是非池化的堆外内存（直接内存）。非池化的ByteBuf 就是利用完之...
吃透Netty源码系列三十四之PooledByteBuf相关补充
王伟王胖胖的博客
02-23 1418
吃透Netty源码系列三十四之PooledByteBuf相关简介PooledByteBuf主要属性PooledHeapByteBufPooledDirectByteBufPooledUnsafeDirectByteBufPooledUnsafeHeapByteBuf PooledByteBuf 前面介绍了一大堆内存管理，对象池的东西，就是为了讲这个，现在再去理解容易多了。 跟前面的Unpoole...
吃透Netty源码系列十八之PooledByteBuf预备知识jemalloc简介
王伟王胖胖的博客
02-13 1045
吃透Netty源码系列十八之PooledByteBuf预备知识jemallocjemalloc内存分配算法简介解决的问题更加细粒度的分配 jemalloc内存分配算法简介 为什么要讲这个呢，因为netty的池化内存分配就是这个的改进版，要想更好的了解改进版，当然要先知道他的原版是怎么样的啦，要知道为什么他要用这个分配算法，能解决什么问题。首先这个是一篇论文里提出来的构想，还有他的源码[github...
【Netty源码】ByteBuf源码剖析
白夜行
08-01 792
ByteBuf概述1.ByteBuf与ByteBuffer的区别 ByteBuf不是对ByteBuffer的封装，而是重新实现了一个缓冲区。ByteBuffer只使用了一个position指针来记录当前的读写位置，ByteBuf使用了两个指针readerIndex, writerIndex分别来记录当前的读写位置，使用起来更加简单和方便。 ByteBuffer是一个固定长度的缓冲区，当put方法要写
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值