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/

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值