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

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