Netty - ByteBuf (2)

最新推荐文章于 2023-06-21 00:00:00 发布
最新推荐文章于 2023-06-21 00:00:00 发布
阅读量174 收藏
点赞数
文章标签： netty java javascript ViewUI

1. Netty - ByteBuf (2)

1.2. netty的ByteBuf

1.2.1. ByteBuf结构

Bytebuf是netty中的ByteBuffer，结构上通过两个位置指针协助缓冲区的读写操作。分别是writerIndex和readerIndex
初始状态：
这里写图片描述
当写入5个字节后：
这里写图片描述
这时，writerIndex为5，这时如果开始读取，那么这个writerIndex可以作为上面ByteBuffer flip之后的limit。
当读取3个字节后：
这里写图片描述

1.2.2. 写溢出问题

ByteBuf对于写操作进行了封装，防止写入应该被释放的ByteBuf或者写入时空间不够，我们查看下主要类的代码：
AbstractByteBuf.java：

public ByteBuf writeByte(int value) {
        //检查buffer是否已经被释放
        ensureAccessible();
        //确认空间足够写入，否则扩容
        ensureWritable(1);
        //当前writerIndex的Byte写入value，并把writerIndex+1
        _setByte(writerIndex++, value);
        //return自己实现流式操作命令
        return this;
}

AbstractByteBuffer.ensureAccessible():

protected final void ensureAccessible() {
        //如果该buffer的引用计数为零，证明应该被释放
        if (refCnt() == 0) {
            throw new IllegalReferenceCountException(0);
        }
}

AbstractByteBuffer.ensureWritable():

public ByteBuf ensureWritable(int minWritableBytes) {
        if (minWritableBytes < 0) {
            throw new IllegalArgumentException(String.format(
                    "minWritableBytes: %d (expected: >= 0)", minWritableBytes));
        }
        //如果剩余空间足够写，则返回
        if (minWritableBytes <= writableBytes()) {
            return this;
        }
        //如果不够，而且要写入的字节数与原有的加起来大于最大容量，则抛异常（这是一个运行时异常）
        if (minWritableBytes > maxCapacity - writerIndex) {
            throw new IndexOutOfBoundsException(String.format(
                    "writerIndex(%d) + minWritableBytes(%d) exceeds maxCapacity(%d): %s",
                    writerIndex, minWritableBytes, maxCapacity, this));
        }

        // 新的capacity容量计算，Normalize the current capacity to the power of 2.
        int newCapacity = alloc().calculateNewCapacity(writerIndex + minWritableBytes, maxCapacity);

        // Adjust to the new capacity.
        capacity(newCapacity);
        return this;
}

新的capacity计算策略：
AbstractByteBufAllocator.calculateNewCapacity(int minNewCapacity, int maxCapacity):

public int calculateNewCapacity(int minNewCapacity, int maxCapacity) {
    if (minNewCapacity < 0) {
        throw new IllegalArgumentException("minNewCapacity: " + minNewCapacity + " (expectd: 0+)");
    }
    if (minNewCapacity > maxCapacity) {
        throw new IllegalArgumentException(String.format(
                "minNewCapacity: %d (expected: not greater than maxCapacity(%d)",
                minNewCapacity, maxCapacity));
    }
    //基础为4MB，步长也为4MB
    final int threshold = 1048576 * 4;
    //如果4MB恰好，则返回4MB
    if (minNewCapacity == threshold) {
        return threshold;
    }

    // 如果不够，每次增长4MB，直到足够或者到达最大容量限制
    if (minNewCapacity > threshold) {
        int newCapacity = minNewCapacity / threshold * threshold;
        if (newCapacity > maxCapacity - threshold) {
            newCapacity = maxCapacity;
        } else {
            newCapacity += threshold;
        }
        return newCapacity;
    }

    // 如果4MB大于minNewCapacity，则从64B开始，每次乘以2，直到大于minNewCapacity
    int newCapacity = 64;
    while (newCapacity < minNewCapacity) {
        newCapacity <<= 1;
    }

    return Math.min(newCapacity, maxCapacity);
}

1.2.3. Mark和Reset

和ByteBuffer中的Mark还有Reset类似，mark记录当前标记，reset回滚到之前标记的位置
AbstractByteBuffer.java

public ByteBuf markReaderIndex() {
    markedReaderIndex = readerIndex;   
    return this;
}

public ByteBuf resetReaderIndex() {
    readerIndex(markedReaderIndex);
    return this;
}

public ByteBuf markWriterIndex() {
    markedWriterIndex = writerIndex;
    return this;
}

public ByteBuf resetWriterIndex() {
    writerIndex = markedWriterIndex;
    return this;
}

1.2.4. discardReadBytes操作

和ByteBuffer中的compact()类似：
这里写图片描述
AbstractByteBuffer.java

public ByteBuf discardReadBytes() {
    ensureAccessible();
    //如果一个字节也没有读取过，则不作任何操作
    if (readerIndex == 0) {
        return this;
    }
    //如果没有全都读取完
    if (readerIndex != writerIndex) {
        //将这个ByteBuf的从readerIndex开始长度为writerIndex - readerIndex的内容移动到从0开始的位置
        setBytes(0, this, readerIndex, writerIndex - readerIndex);
        //修改writerIndex为writerIndex - readerIndex
        writerIndex -= readerIndex;
        //修改markers
        adjustMarkers(readerIndex);
        readerIndex = 0;
    } 
    //如果全都读取完了
    else {
        adjustMarkers(readerIndex);
        writerIndex = readerIndex = 0;
    }
    return this;
}

protected final void adjustMarkers(int decrement) {
        int markedReaderIndex = this.markedReaderIndex;
        //如果小于decrement就置为0，如果不就减去decrement
        if (markedReaderIndex <= decrement) {
            this.markedReaderIndex = 0;
            int markedWriterIndex = this.markedWriterIndex;
            if (markedWriterIndex <= decrement) {
                this.markedWriterIndex = 0;
            } else {
                this.markedWriterIndex = markedWriterIndex - decrement;
            }
        } else {
            this.markedReaderIndex = markedReaderIndex - decrement;
            markedWriterIndex -= decrement;
        }
    }

注意，这个操作很费时，因为需要大量的复制操作，是一种时间换空间的操作，如果可以，尽量避免。

1.2.5. Clear 操作

也和ByteBuffer中的clear()类似：
AbstractByteBuffer.java

public ByteBuf clear() {
        readerIndex = writerIndex = 0;
        return this;
}

1.2.6. 转换成标准的ByteBuffer

ByteBuffer nioBuffer()与ByteBuffer nioBuffer(int index, int length)
查看其中一种实现：
PooledDirectByteBuf.java

public ByteBuffer nioBuffer(int index, int length) {
    checkIndex(index, length);
    index = idx(index);
    return ((ByteBuffer) memory.duplicate().position(index).limit(index + length)).slice();
}

可以断定，和原来的ByteBuf公用同一块内存空间。

1.2.7. 查找

  1. public int indexOf(int fromIndex, int toIndex, byte value)
    起点是fromIndex，终点是toIndex，找到第一个值为value的索引。fromIndex可以大于或者小于toIndex，没找到返回-1
  2. bytesBefore，检查第一个value的索引与index的相对位置大小
public int bytesBefore(byte value) {
    //从readerIndex开始，检查所有可读字节
    return bytesBefore(readerIndex(), readableBytes(), value);
}

public int bytesBefore(int length, byte value) {
    //首先检查length与可读字节大小比较
    checkReadableBytes(length);
    //从readerIndex开始，检查length字节
    return bytesBefore(readerIndex(), length, value);
}

public int bytesBefore(int index, int length, byte value) {
    int endIndex = indexOf(index, index + length, value);
    //如果小于零，代表没找到
    if (endIndex < 0) {
        return -1;
    }
    //返回value的位置索引减去起始索引
    return endIndex - index;
}
  1. forEachByte
    ByteBufProcessor.java
package io.netty.buffer;

public interface ByteBufProcessor {

    /**
     * Aborts on a {@code NUL (0x00)}.
     */
    ByteBufProcessor FIND_NUL = new ByteBufProcessor() {
        @Override
        public boolean process(byte value) throws Exception {
            return value != 0;
        }
    };

    /**
     * Aborts on a non-{@code NUL (0x00)}.
     */
    ByteBufProcessor FIND_NON_NUL = new ByteBufProcessor() {
        @Override
        public boolean process(byte value) throws Exception {
            return value == 0;
        }
    };

    /**
     * Aborts on a {@code CR ('\r')}.
     */
    ByteBufProcessor FIND_CR = new ByteBufProcessor() {
        @Override
        public boolean process(byte value) throws Exception {
            return value != '\r';
        }
    };

    /**
     * Aborts on a non-{@code CR ('\r')}.
     */
    ByteBufProcessor FIND_NON_CR = new ByteBufProcessor() {
        @Override
        public boolean process(byte value) throws Exception {
            return value == '\r';
        }
    };

    /**
     * Aborts on a {@code LF ('\n')}.
     */
    ByteBufProcessor FIND_LF = new ByteBufProcessor() {
        @Override
        public boolean process(byte value) throws Exception {
            return value != '\n';
        }
    };

    /**
     * Aborts on a non-{@code LF ('\n')}.
     */
    ByteBufProcessor FIND_NON_LF = new ByteBufProcessor() {
        @Override
        public boolean process(byte value) throws Exception {
            return value == '\n';
        }
    };

    /**
     * Aborts on a {@code CR ('\r')} or a {@code LF ('\n')}.
     */
    ByteBufProcessor FIND_CRLF = new ByteBufProcessor() {
        @Override
        public boolean process(byte value) throws Exception {
            return value != '\r' && value != '\n';
        }
    };

    /**
     * Aborts on a byte which is neither a {@code CR ('\r')} nor a {@code LF ('\n')}.
     */
    ByteBufProcessor FIND_NON_CRLF = new ByteBufProcessor() {
        @Override
        public boolean process(byte value) throws Exception {
            return value == '\r' || value == '\n';
        }
    };

    /**
     * Aborts on a linear whitespace (a ({@code ' '} or a {@code '\t'}).
     */
    ByteBufProcessor FIND_LINEAR_WHITESPACE = new ByteBufProcessor() {
        @Override
        public boolean process(byte value) throws Exception {
            return value != ' ' && value != '\t';
        }
    };

    /**
     * Aborts on a byte which is not a linear whitespace (neither {@code ' '} nor {@code '\t'}).
     */
    ByteBufProcessor FIND_NON_LINEAR_WHITESPACE = new ByteBufProcessor() {
        @Override
        public boolean process(byte value) throws Exception {
            return value == ' ' || value == '\t';
        }
    };

    /**
     * @return {@code true} if the processor wants to continue the loop and handle the next byte in the buffer.
     *         {@code false} if the processor wants to stop handling bytes and abort the loop.
     */
    boolean process(byte value) throws Exception;
}

对于forEachByte方法，一般为根据ByteBufProcessor 的实现，查找匹配的字节并返回对应的索引

@Override
public int forEachByte(ByteBufProcessor processor) {
    int index = readerIndex;
    int length = writerIndex - index;
    ensureAccessible();
    //默认为顺序操作
    return forEachByteAsc0(index, length, processor);
}

@Override
public int forEachByte(int index, int length, ByteBufProcessor processor) {
    checkIndex(index, length);
    return forEachByteAsc0(index, length, processor);
}

private int forEachByteAsc0(int index, int length, ByteBufProcessor processor) {
    if (processor == null) {
        throw new NullPointerException("processor");
    }

    if (length == 0) {
        return -1;
    }

    final int endIndex = index + length;
    int i = index;
    try {
        do {
            if (processor.process(_getByte(i))) {
                i ++;
            } else {
                return i;
            }
        } while (i < endIndex);
    } catch (Exception e) {
        PlatformDependent.throwException(e);
    }

    return -1;
}

@Override
public int forEachByteDesc(ByteBufProcessor processor) {
    int index = readerIndex;
    int length = writerIndex - index;
    ensureAccessible();
    return forEachByteDesc0(index, length, processor);
}

@Override
public int forEachByteDesc(int index, int length, ByteBufProcessor processor) {
    checkIndex(index, length);

    return forEachByteDesc0(index, length, processor);
}

private int forEachByteDesc0(int index, int length, ByteBufProcessor processor) {

    if (processor == null) {
        throw new NullPointerException("processor");
    }

    if (length == 0) {
        return -1;
    }

    int i = index + length - 1;
    try {
        do {
            if (processor.process(_getByte(i))) {
                i --;
            } else {
                return i;
            }
        } while (i >= index);
    } catch (Exception e) {
        PlatformDependent.throwException(e);
    }

    return -1;
}

1.2.8. 视图与复制

和ByteBuffer中的类似：

  1. duplicate：复制，共享空间，但是各自维护自己的内容指针
  2. copy：复制，各自独立空间，各自维护自己的内容指针
    copy(int index,int length)从index开始复制length长度，各自独立空间，各自维护自己的内容指针
  3. slice：复制从readerIndex到writerIndex的内容，共享空间，各自维护自己的内容指针。
    slice(int index,int length)从index开始复制length长度，共享空间，各自维护自己的内容指针。

1.2.9. 随机读写

会检查有效性

<script type="text/javascript"> $(function () { $('pre.prettyprint code').each(function () { var lines = $(this).text().split('\n').length; var $numbering = $('<ul/>').addClass('pre-numbering').hide(); $(this).addClass('has-numbering').parent().append($numbering); for (i = 1; i <= lines; i++) { $numbering.append($('<li/>').text(i)); }; $numbering.fadeIn(1700); }); }); </script>
iteye_20566
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Netty的ByteBuf学习笔记
学无止境的博客
04-18 618
网络编程中，当我们要进行数据传输时，往往需要使用缓冲区，常用的缓冲区就是Java NIO类库提供的java.io.buffer，在NIO编程时，我们主要使用的是ByteBuffer。从功能角度而言，ByteBuffer完全满足NIO编程的需要，但是由于NIO编程的复杂性，ByteBuffer也有其局限性，它的主要缺点如下： ByteBuffer长度固定，一旦分配完成，它的容量不能动态扩展和收缩，当需要编码的POJO对象大于ByteBuffer的容量时，会发生索引越界异常； ByteBuf...
Netty学习笔记（9）——Netty组件ByteBuf
江左煤郎的博客
11-11 1432
1. ByteBuf作用 1. 当进行数据传输时，都会使用到一个缓冲区，在jdk提供的NIO中最常用的就是ByteBuffer，但在使用的时候，我们很容易会感到ByteBuffer有以下缺点： ByteBuffer实际上就是一个Byte数组，所以在一开始进行创建时，就必须要指定其大小，而且不能进行动态扩容以及缩容，这就引起了很多问题，经常会导致数组下标越界异常。 ByteBuffe...
Netty原理篇-ByteBuf
weixin_34236869的博客
12-15 99
实际上，7种基本类型（boolean除外）都有自己的缓冲区实现，不过因为功能、方法、原理基本一致，所以仅讨论ByteBuffer。 Netty Api地址：http://netty.io/5.0/api/ 一 内容概述 NIO ByteBuffer的概述。 Netty ByteBuf的详细讲述，包括读、写、扩容、mark、reset、dupli...
Netty ByteBuf writerIndex和readerIndex理解
guozhaohui628
07-19 1万+
最近在看 Netty ，给我的感觉是很强大，但是也很难学习。这里记录一个关于 ByteBuf 的小知识 ByteBuf.readableBytes() 返回可读的字节数 其实就是等于 writerIndex - readerIndex ，这里我们 debug 看看，如下图 所以同理 ByteBuf.readable() 也就很好理解了，ByteBuf是否有可读的...
Netty之ByteBuf原理解析及应用
踩踩踩从踩的博客
09-30 2658
前言 本篇文章从源码去解析Netty中ByteBuf对Nio中ByteBuf进行对比，做了那些提升并优化。在使用netty框架时，有那些优点；解析ByteBuf如何做到动态扩容得。如何选择合适得ByteBuf ，以及Netty很大得一个特性零拷贝机制都会在这篇博客中进行解析 ...
bytebuf-rs:类似于Netty ByteBuf的ByteBuf的Rust实现
04-16
类似于Netty ByteBuf的ByteBuf的Rust实现
netty-study:看Netty原始记录
03-24
Netty中频道的分类 NioServerSocketChannel服务端的Channel，在服务启动的时候创建，用于接收新连接 NioSocketChannel客服端Channel，在新连接进入时创建，并负责监听数据读写 不安全，用于实现两个频道临时的协议...
netty-learn:Netty4.X社区配套原始码，博客地址：https
03-23
Netty 4.x写一个分区服务器 写个特定服务器 世上最简单的协议不是而是DISCARD（替代）。这个协议将会丢掉任何收到的数据，而不响应。... (( ByteBuf ) msg) . release(); } @Override public voi
对于 Netty ByteBuf 的零拷贝(Zero Copy) 的理解1
08-03
2. wrap 操作：可以将 byte[] 数组、ByteBuf、ByteBuffer 等包装成一个 Netty ByteBuf 对象，避免了拷贝操作。 3. ByteBuf 的 slice 操作：可以将 ByteBuf 分解为多个共享同一个存储区域的 ByteBuf，避免了内存的...
netty 在java中的字节码转换
03-26
netty通信时经常和底层数据交互，C语言和java的数据类型和范围不同，通信时需要转化或兼容，附件为字节码、进制常用的转换类。
Netty 数据传输载体 —— ByteBuf
悟已往之不谏，知来者之可追
11-25 873
在学习编解码的过程中，我们看到 Netty 大量使用了自己实现的 ByteBuf 工具类，ByteBuf 是 Netty 的数据容器，所有网络通信中字节流的传输都是通过 ByteBuf 完成的。然而 JDK NIO 包中已经提供了类似的 ByteBuffer 类，为什么 Netty 还要去重复造轮子呢？那就要好好说说 ByteBuf。 文章目录为什么是 ByteBufByteBuf 内部结构引用计数ByteBuf 分类ByteBuf 核心 API指针操作 API数据读写 API内存管理 APIByteBuf
io.netty学习（七）字节缓冲区 ByteBuf（下）
最新发布
码灵的博客
06-21 411
在了解了 ByteBuffer 的原理之后，再来理解Netty 的 ByteBuf 就比较简单了。ByteBuf 是 Netty 框架封装的数据缓冲区，区别于positionlimitflip等属性和操作来控制ByteBuffer的读写，ByteBuf通过两个位置指针来协助缓冲区的读写操作，分别是readIndex和writeIndex。readIndexwriteIndex和capacity通过以上对于ByteBuf的介绍，相信小伙伴们对于ByteBuf的原理也有了一定的了解。
netty（六） ByteBuf学习.md
孤落
09-17 1941
ByteBuf学习 基于Java Nio的网络通信，必须依赖于ByteBuffer，从程序实际上是借助于ByteBuffer来与Channel进行交互的，可以向Channel读写数据，但是Java Nio原生的ByteBuffer存在一些问题。 ByteBuffer有两种模式：读模式和写模式，写模式切换到读模式的时候，必须显示地调用flip()方法，否则从缓冲区中读数据会出现异常。这就要求程序猿必...
ByteBuffer与ByteBuf用法比较
ycllycll的博客
09-05 1076
一、ByteBuffer实现原理 对于ByteBuffer，其主要有五个属性：mark，position，limit，capacity和array。 mark：记录了当前所标记的索引下标； position：对于写入模式，表示当前可写入数据的下标，对于读取模式，表示接下来可以读取的数据的下标； limit：对于写入模式，表示当前可以写入的数组大小，默认为数组的最大长度，对于读取模式，表示当...
详解ByteBuf缓冲区
学而不思则忘
05-30 3405
1. ByteBuf优点 与Java NIO的Byte Buffer相比，ByteBuf的优势如下： Pooling池化，减少了内存复制和GC，提升了效率 复合缓冲区类型，支持零复制 不需要调用flip()方法去切换读/写模式 扩展性良好 可以自定义缓冲区类型 读取和写入索引分开 方法的链式调用 可以进行引用计数，方便重复使用 2. ByteBuf的逻辑部分 ByteBuf是一个字节容器，内部是一个字节数组。从逻辑上来分，字节容器内部可以分为四个部分。 第一个部分是已用字节，表示已经使用完的废弃的无
netty学习之二:ByteBuf解读
linux_ja的专栏
06-07 2010
ByteBuf原理跟之前的ByteBuffer原理类似，只是扩展和弥补了ByteBuffer的不足，设计原理： 1、初始化writerIndex，readerIndex为0 2、写入N个字节后： 3、读入M 4、discardReadBytes之后： 5、discardReadBytes前后操作： 源码： public ByteBuf discardRead
Netty-ByteBuf
追梦的小狼狗
07-18 631
ByteBuf 由于NIO编程的复杂性，ByteBuffer也有其局限性，主要缺点如下： ByteBuffer长度固定，一旦分配成功，容量无法动态扩展或者伸缩，当需要编码的POJO对象大于ByteBuffer容量，会出现越界 ByteBuffer只有一个标识位置的指针position，读写的时候需要不断地手工调用flip()和rewind()等，否则很容易导致程序失败 ByteBuffer的AP...
Netty ChannelBuffer 简介
热门推荐
lxgwm2008的专栏
07-11 1万+
ChannelBuffer是Netty中比较常用的一个类，其功能类似于字符数组，可以对其进行读写操作。 ChannelBuffer的模型图如下：  +-------------------+------------------+------------------+  | discardable bytes |  readable bytes  |  writable bytes
Netty的ByteBuf如何使用api
05-31
Netty中的ByteBuf是一个可扩展的字节容器，它提供了一系列的API来方便地读取和写入字节数据。下面是一些常见的ByteBuf使用API： 1. 创建ByteBuf对象 可以使用Unpooled工具类来创建ByteBuf对象，例如： ```java ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值