NIO 组件Buffer

重要属性

属性	描述
Capacity	容量, 即可以容纳的最大数据量; 在缓冲区创建时被设定并且不能改变
Limit	表示缓冲区的当前终点, 不能对缓冲区超过极限的位置进行读写操作, 且极限是可以修改的。
Position	位置, 下一个要被读或写的元素的索引, 每次读写缓冲区数据时都会改变数值, 为下次读写做准备
Mark	标记

简单demo

• 代码：

package com.ronnie.nio;

import java.nio.IntBuffer;

public class BasicBuffer {
    public static void main(String[] args) {

        // 举例说明Buffer 的使用
        // 创建一个Buffer, 大小为n, 即可存放n个int

        IntBuffer intBuffer = IntBuffer.allocate(10);

        // 向buffer 存放数据
        for (int i = 0; i < intBuffer.capacity(); i++){
            intBuffer.put( i * 2);
        }

        // 将buffer转换, 读写切换(很重要)
        intBuffer.flip();

        intBuffer.position(1);
        // 设置limit为3, 到不了3
        intBuffer.limit(3);
        while (intBuffer.hasRemaining()){
            System.out.println(intBuffer.get());
        }
    }

• 输出结果: 2 4
• 感觉这个思想和golang里面的channel好像差不多, 不过go的channel好像并不需要flip, 若不指定方向就是双向的。

源码解读

• 属性

      /**
       * The characteristics of Spliterators that traverse and split elements
       * maintained in Buffers.
       * Spliterators 是一个可分割迭代器, 此处用于遍历并分割Buffer中的元素, 此类有三种
       * 特征的Spliterators: 尺寸固定的, 小尺寸的, 有序的三种, 进去看一下都是16进制数 
       */
      static final int SPLITERATOR_CHARACTERISTICS =
          Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.ORDERED;
  
      // Invariants: mark <= position <= limit <= capacity 不变性排序
      private int mark = -1;
      private int position = 0;
      private int limit;
      private int capacity;
  
      // Used only by direct buffers 只能直接被buffers使用
      // NOTE: hoisted here for speed in JNI GetDirectBufferAddress
      // 挂在这用于提升 JNI(Java Native Interface) 中直接获取buffer地址方法的执行速度
      long address;
  

• 常用方法

  • public final int capacity(){}: 返回此缓冲区的容量

     /**
         * Returns this buffer's capacity.
         *
         * @return  The capacity of this buffer
         */
        public final int capacity() {
            return capacity;
        }
    

  • public final int position(){}: 返回此缓冲区的位置

    /**
         * Returns this buffer's position.
         *
         * @return  The position of this buffer
         */
        public final int position() {
            return position;
        }
    
    

  • public final Buffer position(int newPosition){}: 设置此缓冲区的位置

        /**
         * Sets this buffer's position.  If the mark is defined and larger than 
         * the new position then it is discarded.
         * 设置该buffer的位置, 如果此标记已经被定义, 且大于新定义的位置, 那么它就会被
         * 抛弃。
         *
         * @param  newPosition
         *         The new position value; must be non-negative
         *         and no larger than the current limit
         *
         * @return  This buffer
         *
         * @throws  IllegalArgumentException
         *          If the preconditions on <tt>newPosition</tt> do not hold
         */
        public final Buffer position(int newPosition) {
            if ((newPosition > limit) || (newPosition < 0))
                throw new IllegalArgumentException();
            position = newPosition;
            if (mark > position) mark = -1;
            return this;
        }
    

  • public final int limit(){}: 返回此缓冲区的限制

      /**
         * Returns this buffer's limit.
         *
         * @return  The limit of this buffer
         */
        public final int limit() {
            return limit;
        }
    

  • public final Buffer limit(int newLimit){}: 设置此缓冲区的限制

     /**
         * Sets this buffer's limit.  
         * If the position is larger than the new limit then it is set to the new 
         * limit.  
         * 如果位置大于新的limit, 那么就将位置设为新的limit
         * If the mark is defined and larger than the new limit then it is 
         * discarded.
         * 如果此标记已经被定义, 且大于新定义的位置, 那么它就会被抛弃。
         *
         * @param  newLimit
         *         The new limit value; must be non-negative
         *         and no larger than this buffer's capacity
         *
         * @return  This buffer
         *
         * @throws  IllegalArgumentException
         *          If the preconditions on <tt>newLimit</tt> do not hold
         */
        public final Buffer limit(int newLimit) {
            if ((newLimit > capacity) || (newLimit < 0))
                throw new IllegalArgumentException();
            limit = newLimit;
            if (position > limit) position = limit;
            if (mark > limit) mark = -1;
            return this;
        }
    

  • public final Buffer clear(){}: 清除此缓冲区, 即将各个标记恢复到初始状态, 但是数据并没有真正擦除。

        /**
         * Clears this buffer.  
         * The position is set to zero, the limit is set to the capacity, and the 
         * mark is discarded.
         * 位置被设为0, limit被设置为容量, 并且标记被丢弃。
         *
         * <p> Invoke this method before using a sequence of channel-read or
         * <i>put</i> operations to fill this buffer.  For example:
         *
         * <blockquote><pre>
         * buf.clear();     // Prepare buffer for reading
         * in.read(buf);    // Read data</pre></blockquote>
         *
         * <p> This method does not actually erase the data in the buffer, but it
         * is named as if it did because it will most often be used in situations
         * in which that might as well be the case. </p>
         *
         * @return  This buffer
         */
        public final Buffer clear() {
            position = 0;
            limit = capacity;
            mark = -1;
            return this;
        }
    

  • public abstract boolean hasArray(){}: 告知此缓冲区是否具有可访问的底层实现数组

     /**
         * Tells whether or not this buffer is backed by an accessible
         * array.
         *
         * <p> If this method returns <tt>true</tt> then the {@link #array() array}
         * and {@link #arrayOffset() arrayOffset} methods may safely be invoked.
         * </p>
         *
         * @return  <tt>true</tt> if, and only if, this buffer
         *          is backed by an array and is not read-only
         *
         * @since 1.6
         */
        public abstract boolean hasArray();
    

  • public abstract Object array(){}: 返回此缓冲区的底层实现数组

     /**
         * Returns the array that backs this
         * buffer&nbsp;&nbsp;<i>(optional operation)</i>.
         *
         * <p> This method is intended to allow array-backed buffers to be
         * passed to native code more efficiently. 
         * 该方法的目的是允许 底层的 实现数组缓冲区 更有效地被传送到本地编码中。
         * Concrete subclasses provide more strongly-typed return values for this 
         * method.
         * 实体的子类为该方法提供了更多强类型的返回值
         *
         * <p> Modifications to this buffer's content will cause the returned
         * array's content to be modified, and vice versa.
         * 修改该buffer的内容会导致返回的数组的内容也被改变, 反之亦然。
         *
         * <p> Invoke the {@link #hasArray hasArray} method before invoking this
         * method in order to ensure that this buffer has an accessible backing
         * array.  </p>
         * 在调用此方法前请调用hasArray方法来保证该buffer有一个可获取的底层实现数组
         *
         * @return  The array that backs this buffer
         *
         * @throws  ReadOnlyBufferException
         *          If this buffer is backed by an array but is read-only
         *
         * @throws  UnsupportedOperationException
         *          If this buffer is not backed by an accessible array
         *
         * @since 1.6
         */
        public abstract Object array();
    
    

• 其他方法

  • public final Buffer mark(){}: 在此缓冲区的位置设置标记

     /**
         * Sets this buffer's mark at its position.
         *
         * @return  This buffer
         */
        public final Buffer mark() {
            mark = position;
            return this;
        }
    

  • public final Buffer reset(){}: 将此缓冲区的位置重置为以前标记的位置(后悔药?)

     /**
         * Resets this buffer's position to the previously-marked position.
         *
         * <p> Invoking this method neither changes nor discards the mark's
         * value. </p>
         *
         * @return  This buffer
         *
         * @throws  InvalidMarkException
         *          If the mark has not been set
         */
        public final Buffer reset() {
            int m = mark;
            if (m < 0)
                throw new InvalidMarkException();
            // 将位置设为之前的标记
            position = m;
            return this;
        }
    

  • public final Buffer rewind(){}: 重绕此缓冲区

        /**
         * Rewinds this buffer. 
         * The position is set to zero and the mark is discarded.
         * 位置被设为0并且标记被丢弃
         *
         * <p> Invoke this method before a sequence of channel-write or <i>get</i>
         * operations, assuming that the limit has already been set
         * appropriately.  For example:
         *
         * <blockquote><pre>
         * out.write(buf);    // Write remaining data
         * buf.rewind();      // Rewind buffer
         * buf.get(array);    // Copy data into array</pre></blockquote>
         *
         * @return  This buffer
         */
        public final Buffer rewind() {
            position = 0;
            mark = -1;
            return this;
        }
    

  • public final int remaining(){}: 返回当前位置与限制之间的元素数量

    
        /**
         * Returns the number of elements between the current position and the
         * limit.
         *
         * @return  The number of elements remaining in this buffer
         */
        public final int remaining() {
            return limit - position;
        }
    

  • public abstract int arrayOffset(){}: 返回此缓冲区的底层实现数组中第一个缓冲区元素的偏移量

     /**
         * Returns the offset within this buffer's backing array of the first
         * element of the buffer&nbsp;&nbsp;<i>(optional operation)</i>.
         * 返回此缓冲区的底层实现数组中第一个缓冲区元素的偏移量
         *
         * <p> If this buffer is backed by an array then buffer position <i>p</i>
         * corresponds to array index <i>p</i>&nbsp;+&nbsp;<tt>arrayOffset()</tt>.
         *
         * <p> Invoke the {@link #hasArray hasArray} method before invoking this
         * method in order to ensure that this buffer has an accessible backing
         * array.  </p>
         *  在调用此方法前请调用hasArray方法来保证该buffer有一个可获取的底层实现数组
         *
         * @return  The offset within this buffer's array
         *          of the first element of the buffer
         *
         * @throws  ReadOnlyBufferException
         *          If this buffer is backed by an array but is read-only
         *
         * @throws  UnsupportedOperationException
         *          If this buffer is not backed by an accessible array
         *
         * @since 1.6
         */
        public abstract int arrayOffset();
    

  • public abstract boolean isDirect(){}: 告知此缓冲区是否为直接缓冲区

        /**
         * Tells whether or not this buffer is
         * <a href="ByteBuffer.html#direct"><i>direct</i></a>.
         *
         * @return  <tt>true</tt> if, and only if, this buffer is direct
         *
         * @since 1.6
         */
        public abstract boolean isDirect();
    

ByteBuffer

• 是最常用的ByteBuffer类(二进制数组)

• 常用方法:

  • 缓冲区创建相关:

    • public static ByteBuffer allocateDirect(int capacity){}: 创建直接缓冲区

          /**
           * Allocates a new direct byte buffer.
           *
           * <p> The new buffer's position will be zero, its limit will be its
           * capacity, its mark will be undefined, and each of its elements 
           * will be initialized to zero.  
           * 新缓冲区的位置将会为0, 它的limit会是它的容量, 它的标签未被定义, 每个它
           * 元素都会被定义为0.
           * Whether or not it has a {@link #hasArray backing array} is 
           * unspecified.
           * 是否有底层数组未知
           *
           * @param  capacity
           *         The new buffer's capacity, in bytes
           *
           * @return  The new byte buffer
           *
           * @throws  IllegalArgumentException
           *          If the <tt>capacity</tt> is a negative integer
           */
          public static ByteBuffer allocateDirect(int capacity) {
              return new DirectByteBuffer(capacity);
          }
      

    • public static ByteBuffer allocate(int capacity){}: 设置缓冲区的初始容量

          /**
           * Allocates a new byte buffer.
           *
           * <p> The new buffer's position will be zero, its limit will be its
           * capacity, its mark will be undefined, and each of its elements 
           * will be initialized to zero.  
           * 新缓冲区的位置将会为0, 它的limit会是它的容量, 它的标签未被定义, 每个它
           * 元素都会被定义为0.
           * It will have a {@link #array backing array},and its {@link 
           * #arrayOffset array offset} will be zero.
           * 它会有一个底层数组, 并且它的数组偏移量为0
           *
           * @param  capacity
           *         The new buffer's capacity, in bytes
           *
           * @return  The new byte buffer
           *
           * @throws  IllegalArgumentException
           *          If the <tt>capacity</tt> is a negative integer
           */
          public static ByteBuffer allocate(int capacity) {
              if (capacity < 0)
                  throw new IllegalArgumentException();
              return new HeapByteBuffer(capacity, capacity);
          }
      

  • 缓存区存取相关:

    • public abstract byte get(){}: 从当前位置position上get, get之后, position会自动+1

          // -- Singleton get/put methods -- get/put 都是操作单例对象的
      
          /**
           * Relative <i>get</i> method.  
           * Reads the byte at this buffer's current position, and then 
           * increments the position.
           * 读该字节数组在此buffer的当前位置, 并提升位置 
           *
           * @return  The byte at the buffer's current position
           *
           * @throws  BufferUnderflowException
           *          If the buffer's current position is not smaller than its limit
           */
          public abstract byte get();
      

    • public abstract byte get(int index){}: 从绝对位置get, position不会自动+1

       /**
           * Absolute <i>get</i> method.  Reads the byte at the given
           * index.
           *
           * @param  index
           *         The index from which the byte will be read
           *
           * @return  The byte at the given index
           *
           * @throws  IndexOutOfBoundsException
           *          If <tt>index</tt> is negative
           *          or not smaller than the buffer's limit
           */
          public abstract byte get(int index);
      

    • public abstract ByteBuffer put(byte b){}: 从当前位置上添加, put之后, position会自动 +1

          /**
           * Relative <i>put</i> method&nbsp;&nbsp;<i>(optional operation)</i>.
           *
           * <p> Writes the given byte into this buffer at the current
           * position, and then increments the position. </p>
           * 将获取的字节数组写入到该buffer中的当前位置, 并将位置上升
           *
           * @param  b
           *         The byte to be written
           *
           * @return  This buffer
           *
           * @throws  BufferOverflowException
           *          If this buffer's current position is not smaller than its limit
           *
           * @throws  ReadOnlyBufferException
           *          If this buffer is read-only
           */
          public abstract ByteBuffer put(byte b);
      
      

    • public abstract ByteBuffer put(int index, byte b){}: 从绝对位置上put, position不会自动+1

      /**
           * Absolute <i>put</i> method&nbsp;&nbsp;<i>(optional operation)</i>.
           *
           * <p> Writes the given byte into this buffer at the given
           * index. </p>
           *
           * @param  index
           *         The index at which the byte will be written
           *
           * @param  b
           *         The byte value to be written
           *
           * @return  This buffer
           *
           * @throws  IndexOutOfBoundsException
           *          If <tt>index</tt> is negative
           *          or not smaller than the buffer's limit
           *
           * @throws  ReadOnlyBufferException
           *          If this buffer is read-only
           */
          public abstract ByteBuffer put(int index, byte b);
      

    • 咦, 咋么都是抽象方法呐, 自习看一下层级结构:

      

    • 稍微看了一下, 它们的实现类在HeapByteBuffer和DirectByteBuffer中, 后者还调用了sun.misc.unsafe魔术类的方法, 在此就不做衍生了, 有兴趣的自己去撸源码。