Java Netty 学习(二) - NIO基础知识Buffer

从Java1.4开始，出现了NIO，即NEW IO，用作可以替代原有Java IO的API。
本文主要介绍NIO的一些基础知识，后面文章对主要的类进行分析。

What is NIO

对于NIO，需要知道几个概念，Channel，Buffer，非阻塞，Selectors：

• 标准的IO基于字节流和字符流进行操作的，而NIO是基于通道（Channel）和缓冲区（Buffer）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。
  即相关的操作，是针对Channel与与Buffer的。
• 另一方面，Java NIO可以让你非阻塞的使用IO，例如：当线程从通道读取数据到缓冲区时，线程还是可以进行其他事情。当数据被写入到缓冲区时，线程可以继续处理它。从缓冲区写入通道也类似。
• Java NIO引入了选择器的概念，选择器用于监听多个通道的事件（比如：连接打开，数据到达）。因此，单个的线程可以监听多个数据通道。

接下来看看NIO中的Buffer是个啥。

Buffer

先看一个例子：

private static void buffer() throws IOException{
    RandomAccessFile aFile = new RandomAccessFile("/home/anla7856/workspace/io.examples/pom.xml", "rw");
    FileChannel inChannel = aFile.getChannel();
    ByteBuffer buf = ByteBuffer.allocate(48);
    int bytesRead = inChannel.read(buf); 
    while (bytesRead != -1) {
      buf.flip();  //准备读
      while(buf.hasRemaining()){
          System.out.print((char) buf.get()); // 一次从buf中读取一个字节，并且转化为char输出
      }
      buf.clear(); //清空buf，让其处于待写状态。
      bytesRead = inChannel.read(buf);
    }
    aFile.close();
}

对于buffer的使用情况，有以下步骤：

• 先由一个RandomAccessFile获取一个FileChannel
• 由FileChannel读取数据到ByteBuffer中
• 通过flip，把写状态改为读状态
• 清空buf，让其处于写状态。

使用Buffer读写数据一般遵循以下四个步骤：

• 写入数据到Buffer
• 调用flip()方法
• 从Buffer中读取数据
• 调用clear()方法或者compact()方法

Buffer有以下几种实现，对应这8中Java中的基本数据类型：

• ByteBuffer
• CharBuffer
• DoubleBuffer
• FloatBuffer
• IntBuffer
• LongBuffer
• ShortBuffer
• MappedByteBuffer：用于表示内存映射文件

下面以ByteBuffer为例分析。

ByteBuffer内部原理

先看看ByteBuffer的定义：

public abstract class ByteBuffer
    extends Buffer
    implements Comparable<ByteBuffer>
{
    final byte[] hb;                  // 用来存储字节的数组
    final int offset;                 //起始值，主要是当使用直接内存地址，也就是映射的
    boolean isReadOnly;                 // Valid only for heap buffers
    ...

利用一个byte[]数组来作为buffer存储，再看看它的父类Buffer：

public abstract class Buffer {

    /**
     * 对应与spliterator的，说明Buffer具有的特性
     */
    static final int SPLITERATOR_CHARACTERISTICS =
        Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.ORDERED;

    // 不变量: mark <= position <= limit <= capacity
    private int mark = -1;
    private int position = 0;
    private int limit;
    private int capacity;

    // Used only by direct buffers
    // NOTE: hoisted here for speed in JNI GetDirectBufferAddress
    //用于直接内存，直接指明内存地址，jni变量。
    long address;

对于父类Buffer中的几个变量是很有用的，针对于其数组进行各种操作。

• mark：作为一个标记

• position：

  • 当你写数据到Buffer中时，position表示当前的位置。初始的position值为0.当一个byte、long等数据写到Buffer后， position会向前移动到下一个可插入数据的Buffer单元。position最大可为capacity – 1.

  • 当读取数据时，也是从某个特定位置读。当将Buffer从写模式切换到读模式，position会被重置为0. 当从Buffer的position处读取数据时，position向前移动到下一个可读的位置。

• limit：

  • 在写模式下，Buffer的limit表示你最多能往Buffer里写多少数据。 写模式下，limit等于Buffer的capacity。

  • 读模式时， limit表示你最多能读到多少数据。因此，当切换Buffer到读模式时，limit会被设置成写模式下的position值。换句话说，你能读到之前写入的所有数据（limit被设置成已写数据的数量，这个值在写模式下就是position）

• capacity：作为一个内存块，Buffer有一个固定的大小值，也叫“capacity”.你只能往里写capacity个byte、long，char等类型。一旦Buffer满了，需要将其清空（通过读数据或者清除数据）才能继续写数据往里写数据。

position和limit的含义取决于Buffer处在读模式还是写模式。不管Buffer处在什么模式，capacity的含义总是一样的。

看一张图有助以理解：

构造一个ByteBuffer

如何构造一个ByteBuffer呢？
里面的构造函数是包私有的，也就是外部无法直接初始化。
可以有两种方法，这里先说第一种方法：

CharBuffer buf = CharBuffer.allocate(1024);

看看它的代码走向：

    public static ByteBuffer allocate(int capacity) {
        if (capacity < 0)   //检查
            throw new IllegalArgumentException();
        return new HeapByteBuffer(capacity, capacity);
    }

再看看HeapByteBuffer，这个是ByteBuffer的子类，读过源码就知道，ByteBuffer里面方法大部分是抽象方法，具体实现则交由子类去实现。

    HeapByteBuffer(int cap, int lim) {            // package-private
        super(-1, 0, lim, cap, new byte[cap], 0);
    }

而HeapByteBuffer的构造方法，也是直接调用父类也就是ByteBuffer的方法进行初始化。

第二种方法则是基于MappedByteBuffer进行的，直接通过Unsafe类操作底层存储空间，这里等到单独讲MappedByteBuffer进行分析。

下面看看一些ByteBuffer中重要的方法：

flip方法

这个是父类Buffer中定义的方法，flip方法将Buffer从写模式切换到读模式。调用flip()方法会将position设回0，并将limit设置成之前position的值。
换句话说，position现在用于标记读的位置，limit表示之前写进了多少个byte、char等 —— 现在能读取多少个byte、char等。

    public final Buffer flip() {
        limit = position;
        position = 0;
        mark = -1;
        return this;
    }

rewind方法

rewind()将position设回0，所以你可以重读Buffer中的所有数据。limit保持不变，仍然表示能从Buffer中读取多少个元素（byte、char等）。

    public final Buffer rewind() {
        position = 0;
        mark = -1;
        return this;
    }

clear方法

clear()方法，position将被设回0，limit被设置成 capacity的值。换句话说，Buffer 被清空了。Buffer中的数据并未清除，只是这些标记告诉我们可以从哪里开始往Buffer里写数据。即只是将内部的变量赋予一个初始化的位置。

    public final Buffer clear() {
        position = 0;
        limit = capacity;
        mark = -1;
        return this;
    }

compact方法

如果Buffer中有一些未读的数据，调用clear()方法，数据将“被遗忘”，意味着不再有任何标记会告诉你哪些数据被读过，哪些还没有。
如果Buffer中仍有未读的数据，且后续还需要这些数据，但是此时想要先先写些数据，那么使用compact()方法。
compact()方法将所有未读的数据拷贝到Buffer起始处。然后将position设到最后一个未读元素正后面。limit属性依然像clear()方法一样，设置成capacity。现在Buffer准备好写数据了，但是不会覆盖未读的数据。
compact方法是子类HeapByteBuffer里面的方法：

    public ByteBuffer compact() {
        System.arraycopy(hb, ix(position()), hb, ix(0), remaining());   //拷贝剩余的数组
        position(remaining());      //设置position
        limit(capacity());          //设置limit
        discardMark();               //设置mark
        return this;
    }

equals方法

在ByteBuffer中，重写了equals方法：

    public boolean equals(Object ob) {
        if (this == ob)
            return true;
        if (!(ob instanceof ByteBuffer))             //1，类型一致
            return false;
        ByteBuffer that = (ByteBuffer)ob;
        if (this.remaining() != that.remaining())    //2，剩余数量一致
            return false;
        int p = this.position();
        for (int i = this.limit() - 1, j = that.limit() - 1; i >= p; i--, j--)
            if (!equals(this.get(i), that.get(j)))    //3，剩余的每一项都equals
                return false;
        return true;
    }

如上，只有当满足下面三种条件时候，才能认为equals：

1. 类型一致
2. 剩余数量一致
3. 剩余的每一项都equals

compareTo方法

这个compareTo类似于c++里面的字符串比较方法：

    public int compareTo(ByteBuffer that) {
        int n = this.position() + Math.min(this.remaining(), that.remaining());
        for (int i = this.position(), j = that.position(); i < n; i++, j++) {
            int cmp = compare(this.get(i), that.get(j));        //比较每一个
            if (cmp != 0) 
                return cmp;
        }
        return this.remaining() - that.remaining();         //如果每一个都相等，那么就比较剩余容量
    }

上述compareTo比较两个方面：
1. 比较position开始的每一个元素，终点是二者remaining小的一方
2. 如果都想等，那么就比较remainning。

参考资料：
1. http://ifeve.com/buffers/