Java NIO Buffer

當我們需要與 NIO Channel 進行互動時, 我們就需要使用到 NIO Buffer, 即資料從 Buffer讀取到 Channel 中, 並且從 Channel 中寫入到 Buffer 中.
實際上, 一個 Buffer 其實就是一塊記憶體區域, 我們可以在這個記憶體區域中進行資料的讀寫. NIO Buffer 其實是這樣的記憶體塊的一個封裝, 並提供了一些操作方法讓我們能夠方便地進行資料的讀寫.
Buffer 型別有:

• ByteBuffer

• CharBuffer

• DoubleBuffer

• FloatBuffer

• IntBuffer

• LongBuffer

• ShortBuffer
  這些 Buffer 覆蓋了能從 IO 中傳輸的所有的 Java 基本資料型別.

NIO Buffer 的基本使用

使用 NIO Buffer 的步驟如下:

• 將資料寫入到 Buffer 中.

• 呼叫 Buffer.flip()方法, 將 NIO Buffer 轉換為讀模式.

• 從 Buffer 中讀取資料

• 呼叫 Buffer.clear() 或 Buffer.compact()方法, 將 Buffer 轉換為寫模式.

當我們將資料寫入到 Buffer 中時, Buffer 會記錄我們已經寫了多少的資料, 當我們需要從 Buffer 中讀取資料時, 必須呼叫 Buffer.flip()將 Buffer 切換為讀模式.
一旦讀取了所有的 Buffer 資料, 那麼我們必須清理 Buffer, 讓其從新可寫, 清理 Buffer 可以呼叫 Buffer.clear() 或 Buffer.compact().
例如:

public class Test {
    public static void main(String[] args) {
        IntBuffer intBuffer = IntBuffer.allocate(2);
        intBuffer.put(12345678);
        intBuffer.put(2);
        intBuffer.flip();
        System.err.println(intBuffer.get());
        System.err.println(intBuffer.get());
    }
}
 

上述中, 我們分配兩個單位大小的 IntBuffer, 因此它可以寫入兩個 int 值.
我們使用 put 方法將 int 值寫入, 然後使用 flip 方法將 buffer 轉換為讀模式, 然後連續使用 get 方法從 buffer 中獲取這兩個 int 值.
每當呼叫一次 get 方法讀取資料時, buffer 的讀指標都會向前移動一個單位長度(在這裡是一個 int 長度)

Buffer 屬性

一個 Buffer 有三個屬性:

• capacity

• position

• limit
  其中 position 和 limit 的含義與 Buffer 處於讀模式或寫模式有關, 而 capacity 的含義與 Buffer 所處的模式無關.

Capacity

一個記憶體塊會有一個固定的大小, 即容量(capacity), 我們最多寫入capacity 個單位的資料到 Buffer 中, 例如一個 DoubleBuffer, 其 Capacity 是100, 那麼我們最多可以寫入100個 double 資料.

Position

當從一個 Buffer 中寫入資料時, 我們是從 Buffer 的一個確定的位置(position)開始寫入的. 在最初的狀態時, position 的值是0. 每當我們寫入了一個單位的資料後, position 就會遞增一.
當我們從 Buffer 中讀取資料時, 我們也是從某個特定的位置開始讀取的. 當我們呼叫了 filp()方法將 Buffer 從寫模式轉換到讀模式時, position 的值會自動被設定為0, 每當我們讀取一個單位的資料, position 的值遞增1.
position 表示了讀寫操作的位置指標.

limit

limit - position 表示此時還可以寫入/讀取多少單位的資料.
例如在寫模式, 如果此時 limit 是10, position 是2, 則表示已經寫入了2個單位的資料, 還可以寫入 10 - 2 = 8 個單位的資料.

例子:

public class Test {
    public static void main(String args[]) {
        IntBuffer intBuffer = IntBuffer.allocate(10);
        intBuffer.put(10);
        intBuffer.put(101);
        System.err.println("Write mode: ");
        System.err.println("\tCapacity: " + intBuffer.capacity());
        System.err.println("\tPosition: " + intBuffer.position());
        System.err.println("\tLimit: " + intBuffer.limit());

        intBuffer.flip();
        System.err.println("Read mode: ");
        System.err.println("\tCapacity: " + intBuffer.capacity());
        System.err.println("\tPosition: " + intBuffer.position());
        System.err.println("\tLimit: " + intBuffer.limit());
    }
}

這裡我們首先寫入兩個 int 值, 此時 capacity = 10, position = 2, limit = 10.
然後我們呼叫 flip 轉換為讀模式, 此時 capacity = 10, position = 0, limit = 2;

分配 Buffer

為了獲取一個 Buffer 物件, 我們首先需要分配記憶體空間. 每個型別的 Buffer 都有一個 allocate()方法, 我們可以通過這個方法分配 Buffer:

ByteBuffer buf = ByteBuffer.allocate(48);

這裡我們分配了48 * sizeof(Byte)位元組的記憶體空間.

CharBuffer buf = CharBuffer.allocate(1024);

這裡我們分配了大小為1024個字元的 Buffer, 即 這個 Buffer 可以儲存1024 個 Char, 其大小為 1024 * 2 個位元組.

關於 Direct Buffer 和 Non-Direct Buffer 的區別

Direct Buffer:

• 所分配的記憶體不在 JVM 堆上, 不受 GC 的管理.(但是 Direct Buffer 的 Java 物件是由 GC 管理的, 因此當發生 GC, 物件被回收時, Direct Buffer 也會被釋放)

• 因為 Direct Buffer 不在 JVM 堆上分配, 因此 Direct Buffer 對應用程式的記憶體佔用的影響就不那麼明顯(實際上還是佔用了這麼多記憶體, 但是 JVM 不好統計到非 JVM 管理的記憶體.)

• 申請和釋放 Direct Buffer 的開銷比較大. 因此正確的使用 Direct Buffer 的方式是在初始化時申請一個 Buffer, 然後不斷複用此 buffer, 在程式結束後才釋放此 buffer.

• 使用 Direct Buffer 時, 當進行一些底層的系統 IO 操作時, 效率會比較高, 因為此時 JVM 不需要拷貝 buffer 中的記憶體到中間臨時緩衝區中.

Non-Direct Buffer:

• 直接在 JVM 堆上進行記憶體的分配, 本質上是 byte[] 陣列的封裝.

• 因為 Non-Direct Buffer 在 JVM 堆中, 因此當進行作業系統底層 IO 操作中時, 會將此 buffer 的記憶體複製到中間臨時緩衝區中. 因此 Non-Direct Buffer 的效率就較低.

寫入資料到 Buffer

int bytesRead = inChannel.read(buf); //read into buffer.
buf.put(127);

從 Buffer 中讀取資料

//read from buffer into channel.
int bytesWritten = inChannel.write(buf);
byte aByte = buf.get();

重置 position

Buffer.rewind()方法可以重置 position 的值為0, 因此我們可以重新讀取/寫入 Buffer 了.
如果是讀模式, 則重置的是讀模式的 position, 如果是寫模式, 則重置的是寫模式的 position.
例如:

public class Test {
    public static void main(String[] args) {
        IntBuffer intBuffer = IntBuffer.allocate(2);
        intBuffer.put(1);
        intBuffer.put(2);
        System.err.println("position: " + intBuffer.position());

        intBuffer.rewind();
        System.err.println("position: " + intBuffer.position());
        intBuffer.put(1);
        intBuffer.put(2);
        System.err.println("position: " + intBuffer.position());

        
        intBuffer.flip();
        System.err.println("position: " + intBuffer.position());
        intBuffer.get();
        intBuffer.get();
        System.err.println("position: " + intBuffer.position());

        intBuffer.rewind();
        System.err.println("position: " + intBuffer.position());
    }
}

rewind() 主要針對於讀模式. 在讀模式時, 讀取到 limit 後, 可以呼叫 rewind() 方法, 將讀 position 置為0.

關於 mark()和 reset()

我們可以通過呼叫 Buffer.mark()將當前的 position 的值儲存起來, 隨後可以通過呼叫 Buffer.reset()方法將 position 的值回覆回來.
例如:

public class Test {
    public static void main(String[] args) {
        IntBuffer intBuffer = IntBuffer.allocate(2);
        intBuffer.put(1);
        intBuffer.put(2);
        intBuffer.flip();
        System.err.println(intBuffer.get());
        System.err.println("position: " + intBuffer.position());
        intBuffer.mark();
        System.err.println(intBuffer.get());

        System.err.println("position: " + intBuffer.position());
        intBuffer.reset();
        System.err.println("position: " + intBuffer.position());
        System.err.println(intBuffer.get());
    }
}

這裡我們寫入兩個 int 值, 然後首先讀取了一個值. 此時讀 position 的值為1.
接著我們呼叫 mark() 方法將當前的 position 儲存起來(在讀模式, 因此儲存的是讀的 position), 然後再次讀取, 此時 position 就是2了.
接著使用 reset() 恢復原來的讀 position, 因此讀 position 就為1, 可以再次讀取資料.

flip, rewind 和 clear 的區別

flip

flip 方法原始碼

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

Buffer 的讀/寫模式共用一個 position 和 limit 變數.
當從寫模式變為讀模式時, 原先的 寫 position 就變成了讀模式的 limit.

rewind

rewind 方法原始碼

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

rewind, 即倒帶, 這個方法僅僅是將 position 置為0.

clear

clear 方法原始碼:

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

根據原始碼我們可以知道, clear 將 positin 設定為0, 將 limit 設定為 capacity.
clear 方法使用場景:

• 在一個已經寫滿資料的 buffer 中, 呼叫 clear, 可以從頭讀取 buffer 的資料.

• 為了將一個 buffer 填充滿資料, 可以呼叫 clear, 然後一直寫入, 直到達到 limit.

例子:

IntBuffer intBuffer = IntBuffer.allocate(2);
intBuffer.flip();
System.err.println("position: " + intBuffer.position());
System.err.println("limit: " + intBuffer.limit());
System.err.println("capacity: " + intBuffer.capacity());

// 這裡不能讀, 因為 limit == position == 0, 沒有資料.
//System.err.println(intBuffer.get());

intBuffer.clear();
System.err.println("position: " + intBuffer.position());
System.err.println("limit: " + intBuffer.limit());
System.err.println("capacity: " + intBuffer.capacity());

// 這裡可以讀取資料了, 因為 clear 後, limit == capacity == 2, position == 0,
// 即使我們沒有寫入任何的資料到 buffer 中.
System.err.println(intBuffer.get()); // 讀取到0
System.err.println(intBuffer.get()); // 讀取到0

Buffer 的比較

我們可以通過 equals() 或 compareTo() 方法比較兩個 Buffer, 當且僅當如下條件滿足時, 兩個 Buffer 是相等的:

• 兩個 Buffer 是相同型別的

• 兩個 Buffer 的剩餘的資料個數是相同的

• 兩個 Buffer 的剩餘的資料都是相同的.

通過上述條件我們可以發現, 比較兩個 Buffer 時, 並不是 Buffer 中的每個元素都進行比較, 而是比較 Buffer 中剩餘的元素.

本文連結為: segmentfault.com/a/1190000006824155