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.

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

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

巴特西

NIO Buffer 内部机理使用姿势

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

NIO Buffer 常用方法介绍

最新文章

热门文章

巴特西

NIO Buffer 内部机理使用姿势

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

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

最新文章

热门文章

NIO Buffer 常用方法介绍