NIO Buffer 内部机理使用姿势

关于NIO Buffer中4个重要状态属性

position、limit、capacity 与 mark

Buffer本身是一个容器,称作缓冲区,里面包装了特定的一种原生类型,其子类包括ByteBuffer、CharBuffer、LongBuffer、IntBuffer、DoubleBuffer、ShortBuffer、FloatBuffer。

注意没有Boolean类型的Buffer

Buffer是一种特定原生类型线性的有限的元素序列,Buffer中比较重要的4个属性:position、limit、capacity、mark. 在使用 Buffer 时,我们实际操作的就是这四个属性的值。

具体介绍下 4 个属性:

  • capacity(容量):
    一个buffer能够容纳数据元素的最大数量,capacity不会为负数,且永远不能被改变。
    假设:IntBuffer.allocate(1024), 分配了大小为1024的元素个数,则capacity就等于1024。

  • limit(上界):一个buffer的limit指的是第一个不能在读也不能在写的元素索引. limit不会为负数,并且一定是小于capacity的。

假设:IntBuffer.allocate(1024), 我们在程序中设置limit=512,说明Buffer的容量是1024,但是从512之后既不能读也不能写了,进一步说明该Buffer的实际可用大小是512。

  • position(位置):一个buffer的position指的是下一个将要读或者写的元素的索引.position不会为负数,并且一定是小于limit的. position的位置主要由get()和put()方法的调用来更新。

  • mark(标记):
    一个备忘地址,作为临时标记位置使用,标记在设定前是未定义的。

mark的使用场景:

假设 IntBuffer.allocate(1024),现在position位置为10,现在只想发送512到1024之间的缓冲数据,此时我们可以buffer.mark(buffer.position())既将position记入mark位置,然后buffer.postion(512),此时发送的数据就是512到1024之间的数据。发送完成后,调用buffer.reset()将mark临时标记赋值给position使得position=mark。注意如果未设定mark,而调用了buffer.reset()方法则会抛出InvalidMarkException。

不变式:

0 <= mark <= position <= limit <= capacity

传输数据:

Buffer中的每个子类中都有get()和put()方法.
带参数的put和get方法称作绝对存入/取出,位置是通过参数指定的.
绝对操作不影响position位置,但是如果索引位置超出limit,则会抛出IndexOutOfBoundsException;
不带参数的put和get称作相对存入/取出,即position位置自动前进.
对于get相对操作,如果位置超过了limit,则会抛出BufferUnderflowException;
对于put相对操作,如果位置超过了limit,则会抛出BufferOverflowException;

线程安全性:

buffer在多线程并发下并不是安全的。如果一个buffer会在多个线程使用,那么需要使用恰当的同步操作来访问buffer。也就是buffer本身并不是线程安全的。

** NIO Buffer 常用方法介绍**

这部分我们以实际代码为例来说明:

clear() 方法:

清除,将buffer重置为空状态,它并不会更改缓冲区内的任何数据元素. 如果此时还没有读取的数据,则就无法读取到了。

public final Buffer clear() {
        position = 0; // 位置重置为0
        limit = capacity; // limit重置为capacity
        mark = -1; // 丢弃标记
        return this;
}

flip() 方法:

翻转,使buffer从写模式转换到读模式。

源码:

public final Buffer flip() {
        limit = position; // 将limit设置为position
        position = 0; // position重置为0
        mark = -1; // 丢弃标记
        return this;
}

rewind() 方法:

重绕,重置position为0,limit保持不变,此时调用rewind前buffer已处于读模式下了, 可以重新读取buffer中的数据。

源码:

public final Buffer rewind() {
        position = 0; // 重置position为0
        mark = -1; // 丢弃标记 
        return this;
}

compact() 方法:

将所有未读的数据拷贝到Buffer起始处. 然后将position设到最后一个未读元素正后面. limit属性依然像clear()方法一样,设置成capacity. 现在Buffer准备好写数据了,但是不会覆盖未读的数据。

注意compact方法的实现是由原生类型的子类实现,比如ByteBuffer则由HeapByteBuffer中实现。

源码:

public ByteBuffer compact() {
        System.arraycopy(hb, ix(position()), hb, ix(0), remaining());
        position(remaining());
        limit(capacity());
        discardMark();
        return this;
 }

hasRemaining() 方法:

会在读取缓冲区时告诉你是否已经达到缓冲区的上界. 可以通过remaining()高效读取buffer数据。

int count = buffer.remaining();  
for (int i = 0; i < count; i++) {  
    myByteArray[i] = buffer.get();  
} 

slice() 方法:

对原有数据的一个快照,共享相同的底层数据元素. 调用slice方法后,会得到大于等于position且小于limit之间的数据,对于改变slice方法获得大buffer数据,也能够反映到原buffer上。

示例代码:

public class NioTest_slice {
    public static void main(String[] args) {
        ByteBuffer byteBuffer = ByteBuffer.allocate(10);
        int capacity = byteBuffer.capacity();
        for (int i = 0 ; i < capacity; i++) {
            byteBuffer.put((byte)i);
        }

        // 设置position、limit
        byteBuffer.position(2);
        byteBuffer.limit(6);

        //slice方法是前闭后开的 大于等于position,小于limit
        ByteBuffer subByteBuffer = byteBuffer.slice();

        // 改变subByteBuffer内容,也能反映到byteBuffer上
        for (int j = 0; j < subByteBuffer.capacity(); j++) {
            // 2到5位置的数*2
            subByteBuffer.put((byte)(2 * subByteBuffer.get(j)));
        }

        // 设置回原来的值,打印输出看下byteBuffer数据变化
        byteBuffer.position(0);
        byteBuffer.limit(capacity);
        while (byteBuffer.hasRemaining()) {
            System.out.println(byteBuffer.get());
        }
    }
}

输出结果中看到第3个位置到第5个位置的数据都✖️2了,返回4,6,8.

0
1
4
6 
8 
10
6
7
8
9

duplicate() 方法:

创建了一个与原始缓冲区相似的新缓冲区,与调用slice方法一样也是共享相同的底层数据元素, 拥有同样的容量, 但每个缓冲区拥有各自的 position、limit 和 mark 属性。

示例代码:

public class NioTest_duplicate {
    public static void main(String[] args) {
        ByteBuffer byteBuffer = ByteBuffer.allocate(10);
        int capacity = byteBuffer.capacity();
        for (int i = 0 ; i < capacity; i++) {
            byteBuffer.put((byte)i);
        }

        ByteBuffer subByteBuffer = byteBuffer.duplicate();
        subByteBuffer.position(0); // 单独给duplicate出来的buffer设置position
        System.out.println("byteBuffer position:" + byteBuffer.position() + "--subByteBuffer position:" + subByteBuffer.position());

        // 改变subByteBuffer内容,也能反映到byteBuffer上
        for (int j = 0; j < subByteBuffer.capacity(); j++) {
            // 2到5位置的数*2
            subByteBuffer.put((byte)(2 * subByteBuffer.get(j)));
        }

        // 切换到读模式
        byteBuffer.flip();
        while (byteBuffer.hasRemaining()) {
            System.out.println(byteBuffer.get());
        }
    }
}

输出结果能看到原buffer数据元素变化

byteBuffer position:10--subByteBuffer position:0
0
2
4
6
8
10
12
14
16
18

asReadOnlyBuffer() 方法:

我们可以随时将一个普通的Buffer调用asReadOnlyBuffer方法返回一个只读Buffer. 但是,不能将一个只读Buffer转换为读写Buffer。

**关于 Buffer 的 Scattering 和 Gathering **

scatter / gather经常用于需要将传输的数据分开处理的场合,例如传输一个由消息头和消息体组成的消息,你可能会将消息体和消息头分散到不同的buffer中,这样你可以方便的处理消息头和消息体。

Scattering:

Scattering Reads在移动下一个buffer前,必须填满当前的buffer,这也意味着它不适用于动态消息(译者注:消息大小不固定). 换句话说,如果存在消息头和消息体,消息头必须完成填充(例如 128byte),Scattering Reads才能正常工作。

Gattering:

buffer数组是write()方法的入参,write()方法会按照buffer在数组中的顺序,将数据写入到channel,注意只有position和limit之间的数据才会被写入。
因此,如果一个buffer的容量为128byte,但是仅仅包含58byte的数据,那么这58byte的数据将被写入到channel中。因此与Scattering Reads相反,Gathering Writes能较好的处理动态消息。

示例代码:

public class NioTest_scatteringandgathering {

    public static void main(String[] args) throws  Exception {
        try(ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();) {
            InetSocketAddress inetSocketAddress = new InetSocketAddress(8899);
            serverSocketChannel.socket().bind(inetSocketAddress); // 绑定到8899端口


            int messageLength = 2 + 3 + 4;

            ByteBuffer[] byteBuffers = new ByteBuffer[3];
            byteBuffers[0] = ByteBuffer.allocate(2);
            byteBuffers[1] = ByteBuffer.allocate(3);
            byteBuffers[2] = ByteBuffer.allocate(4);

            SocketChannel socketChannel = serverSocketChannel.accept();

            do {
                int byteRead = 0;
                while (byteRead < messageLength) {
                    long r = socketChannel.read(byteBuffers);
                    System.out.println("--------------r:" + r);
                    byteRead += r;

                    System.out.println("byteRead:" + byteRead);

                    Arrays.asList(byteBuffers).stream().map(buffer -> "position:" + buffer.position() + ", limit:" + buffer.limit())
                            .forEach(System.out::println);
                }

                Arrays.asList(byteBuffers).forEach(Buffer::flip);

                // 实际写的个数
                int byteWrites = 0;
                while (byteWrites < messageLength) {
                    long r = socketChannel.write(byteBuffers);
                    byteWrites += r;
                }

                Arrays.asList(byteBuffers).forEach(Buffer::clear);

                System.out.println("byteRead:" + byteRead + ", byteWrite:" + byteWrites + ", messageLength:" + messageLength);
            } while (true);
        }
    }
}

以上服务启动后,我们通过nc localhost 8899或者telecom localhost 8899,然后输入Hello world字符串。

控制台上能看到输出:

--------------r:9
byteRead:9
position:2, limit:2
position:3, limit:3
position:4, limit:4
byteRead:9, byteWrite:9, messageLength:9

欢迎关注我的公众号,扫二维码关注,文章首发到公众号,与你一同成长~

Java爱好者社区

posted @ 2019-12-19 12:09  Java爱好者社区  阅读(89)  评论(0编辑  收藏