Java NIO —— Buffer（缓冲区）

Buffer是一个抽象类，位于java.nio包中，主要用作缓冲区。注意：Buffer是非线程安全类。

缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。

NIO 有以下几种Buffer类型：

• ByteBuffer
• MappedByteBuffer
• CharBuffer
• DoubleBuffer
• FloatBuffer
• IntBuffer
• LongBuffer
• ShortBuffer

capacity

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

capacity一旦初始化 
后就不会改变，其值一直为常量。在使用中我们一般使用Buffer的抽象子类ByteBuffer.allocate()方法，实际上是生成ByteArrayBuffer类。

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。

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

（1）Buffer中定义的变量含义

/**
 * <code>UNSET_MARK</code> means the mark has not been set.
 */
static final int UNSET_MARK = -1;

/**
 * The capacity of this buffer, which never changes.
 */
final int capacity;

/**
 * <code>limit - 1</code> is the last element that can be read or written.
 * Limit must be no less than zero and no greater than <code>capacity</code>.
 */
int limit;

/**
 * Mark is where position will be set when <code>reset()</code> is called.
 * Mark is not set by default. Mark is always no less than zero and no
 * greater than <code>position</code>.
 */
int mark = UNSET_MARK;

/**
 * The current position of this buffer. Position is always no less than zero
 * and no greater than <code>limit</code>.
 */
int position = 0;

/**
 * The log base 2 of the element size of this buffer.  Each typed subclass
 * (ByteBuffer, CharBuffer, etc.) is responsible for initializing this
 * value.  The value is used by JNI code in frameworks/base/ to avoid the
 * need for costly ‘instanceof‘ tests.
 */
final int _elementSizeShift;

/**
 * For direct buffers, the effective address of the data; zero otherwise.
 * This is set in the constructor.
 */
final long effectiveDirectAddress;

（2）clear()方法用于写模式，其作用为清空Buffer中的内容，所谓清空是指写上限与Buffer的真实容量相同，即limit==capacity,同时将当前写位置置为最前端下标为0处。代码如下：

/**
 * <code>UNSET_MARK</code> means the mark has not been set.
 */
static final int UNSET_MARK = -1;

/**
 * Clears this buffer.
 * <p>
 * While the content of this buffer is not changed, the following internal
 * changes take place: the current position is reset back to the start of
 * the buffer, the value of the buffer limit is made equal to the capacity
 * and mark is cleared.
 *
 * @return this buffer.
 */
public final Buffer clear() {
    position = 0; //设置当前下标为0 
    mark = UNSET_MARK; //取消标记 
    limit = capacity; //设置写越界位置与和Buffer容量相同  
    return this;
}

（3）reset()方法和clear()方法一样用于写模式，区别是reset()的作用是丢弃mark位置以后的数据，重新从mark位置开始写入，且mark不能未设置；而clear是从0位置开始重新写入。

• /**
   * Sets this buffer‘s mark at its position.
   *
   * @return  This buffer
   */
  public final Buffer mark() {
      mark = position;
      return this;
  }
  
  /**
   * Resets the position of this buffer to the <code>mark</code>.
   *
   * @return this buffer.
   * @throws InvalidMarkException
   *                if the mark is not set.
   */
  public final Buffer reset() {
      if (mark == UNSET_MARK) {
          throw new InvalidMarkException("Mark not set");
      }
      position = mark;
      return this;
  }

   

（4）rewind()在读写模式下都可用，它单纯的将当前位置置0，同时取消mark标记，仅此而已；也就是说写模式下limit仍保持与Buffer容量相同，只是重头写而已；读模式下limit仍然与rewind()调用之前相同，也就是为flip()调用之前写模式下的position的最后位置，flip()调用后此位置变为了读模式的limit位置，即越界位置，代码如下：

/**
 * Rewinds this buffer.
 * <p>
 * The position is set to zero, and the mark is cleared. The content of this
 * buffer is not changed.
 *
 * @return this buffer.
 */
public final Buffer rewind() {
    position = 0;
    mark = UNSET_MARK;
    return this;
}

（5）flip()函数的作用是将写模式转变为读模式，即将写模式下的Buffer中内容的最后位置变为读模式下的limit位置，作为读越界位置，同时将当前读位置置为0，表示转换后重头开始读，同时再消除写模式下的mark标记，代码如下

/**
 * Flips this buffer.
 * <p>
 * The limit is set to the current position, then the position is set to
 * zero, and the mark is cleared.
 * <p>
 * The content of this buffer is not changed.
 *
 * @return this buffer.
 */
public final Buffer flip() {
    limit = position;
    position = 0;
    mark = UNSET_MARK;
    return this;
}

（6）remaining()仅在读模式下使用，用来获取还未读出的字节数。

• /**
   * Returns the number of remaining elements in this buffer, that is
   * {@code limit - position}.
   *
   * @return the number of remaining elements in this buffer.
   */
  public final int remaining() {
      return limit - position;
  }

   

（7）Buffer的抽象子类ByteBuffer的compact()方法也蛮重要的。compact()的作用是压缩数据。比如当前EOF是6，当前指针指向2（即0,1的数据已经写出了，没用了），那么compact方法将把2,3,4,5的数据挪到0,1,2,3的位置，然后指针指向4的位置。这样的意思是，从4的位置接着再写入数据。

/**
 * Compacts this byte buffer.
 * <p>
 * The remaining bytes will be moved to the head of the
 * buffer, starting from position zero. Then the position is set to
 * {@code remaining()}; the limit is set to capacity; the mark is
 * cleared.
 *
 * @return {@code this}
 * @throws ReadOnlyBufferException
 *                if no changes may be made to the contents of this buffer.
 */
public abstract ByteBuffer compact();

（8）equals()

当满足下列条件时，表示两个Buffer相等：

• 有相同的类型（byte、char、int等）。
• Buffer中剩余的byte、char等的个数相等。
• Buffer中所有剩余的byte、char等都相同。

equals只是比较Buffer的一部分，不是每一个在它里面的元素都比较（即它只比较Buffer中的剩余元素）。

以ByteBuffer为例

• /**
   * Tells whether or not this buffer is equal to another object.
   *
   * <p> Two byte buffers are equal if, and only if,
   *
   * <ol>
   *
   *   <li><p> They have the same element type,  </p></li>
   *
   *   <li><p> They have the same number of remaining elements, and
   *   </p></li>
   *
   *   <li><p> The two sequences of remaining elements, considered
   *   independently of their starting positions, are pointwise equal.
   *   </p></li>
   *
   * </ol>
   *
   * <p> A byte buffer is not equal to any other type of object.  </p>
   *
   * @param  ob  The object to which this buffer is to be compared
   *
   * @return  <tt>true</tt> if, and only if, this buffer is equal to the
   *           given object
   */
  public boolean equals(Object ob) {
      if (this == ob)
          return true;
      if (!(ob instanceof ByteBuffer))
          return false;
      ByteBuffer that = (ByteBuffer)ob;
      if (this.remaining() != that.remaining())
          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)))
              return false;
      return true;
  }

   

（9）compareTo()

compareTo()方法比较两个Buffer的剩余元素(byte、char等)， 如果满足下列条件，则认为一个Buffer“小于”另一个Buffer：

• 第一个不相等的元素小于另一个Buffer中对应的元素 。
• 所有元素都相等，但第一个Buffer比另一个先耗尽(第一个Buffer的元素个数比另一个少)。

以ByteBuffer为例

• /**
   * Compares this buffer to another.
   *
   * <p> Two byte buffers are compared by comparing their sequences of
   * remaining elements lexicographically, without regard to the starting
   * position of each sequence within its corresponding buffer.
   * Pairs of {@code byte} elements are compared as if by invoking
   * {@link Byte#compare(byte,byte)}.
  
   *
   * <p> A byte buffer is not comparable to any other type of object.
   *
   * @return  A negative integer, zero, or a positive integer as this buffer
   *          is less than, equal to, or greater than the given buffer
   */
  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();
  }

   

补充：

• 由于ByteBuffer是非线程安全的，所以多线程访问的时候也必须加锁。

• ByteBuffer在内部也是利用byte[]作为内存缓冲区，只不过多提供了一些标记变量而已。当多线程访问的时候，可以清楚的知道当前数据的位置。