摘要：當我們需要與進行交互時我們就需要使用到即數據從讀取到中并且從中寫入到中實際上一個其實就是一塊內存區域我們可以在這個內存區域中進行數據的讀寫其實是這樣的內存塊的一個封裝并提供了一些操作方法讓我們能夠方便地進行數據的讀寫類型有這些覆蓋了能從中傳

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

ByteBuffer

CharBuffer

DoubleBuffer

FloatBuffer

IntBuffer

LongBuffer

ShortBuffer
這些 Buffer 覆蓋了能從 IO 中傳輸的所有的 Java 基本數據類型.

使用 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 有三個屬性:

capacity

position

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

一個內存塊會有一個固定的大小, 即容量(capacity), 我們最多寫入capacity 個單位的數據到 Buffer 中, 例如一個 DoubleBuffer, 其 Capacity 是100, 那么我們最多可以寫入100個 double 數據.

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

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("	Capacity: " + intBuffer.capacity());
        System.err.println("	Position: " + intBuffer.position());
        System.err.println("	Limit: " + intBuffer.limit());

        intBuffer.flip();
        System.err.println("Read mode: ");
        System.err.println("	Capacity: " + intBuffer.capacity());
        System.err.println("	Position: " + intBuffer.position());
        System.err.println("	Limit: " + intBuffer.limit());
    }
}

這里我們首先寫入兩個 int 值, 此時 capacity = 10, position = 2, limit = 10.
然后我們調用 flip 轉換為讀模式, 此時 capacity = 10, position = 0, limit = 2;

為了獲取一個 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:

所分配的內存不在 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 的效率就較低.

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

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

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.

我們可以通過調用 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 方法源碼

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

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

rewind 方法源碼

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

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

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

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

兩個 Buffer 是相同類型的

兩個 Buffer 的剩余的數據個數是相同的

兩個 Buffer 的剩余的數據都是相同的.

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

本文由 yongshun 發表于個人博客, 采用署名-非商業性使用-相同方式共享 3.0 中國大陸許可協議.
非商業轉載請注明作者及出處. 商業轉載請聯系作者本人
Email: yongshun1228@gmail.com
本文標題為: Java NIO 的前生今世 之三 NIO Buffer 詳解
本文鏈接為: segmentfault.com/a/1190000006824155