Java NIO Buffer實現原理詳解

/**
 * @author csp
 * @date 2021-11-26 3:51 下午
 */
public class IntBufferDemo {
    public static void main(String[] args) {
        // 分配新的int緩沖區，參數為緩沖區容量。
        // 新緩沖區的當前位置為0，其界限（限制位置）為其容量。它具有一個底層實現數組，其數組偏移量為0。
        IntBuffer buffer = IntBuffer.allocate(8);

        for (int i = 0; i < buffer.capacity(); i++) {
            int j = 2 * (i + 1);
            // 將給定整數寫入此緩沖區的當前位置，當前位置遞增。
            buffer.put(j);
        }

        // 重設此緩沖區，將限制位置設置為當前位置，然後將當前位置設置為0。
        buffer.flip();

        // 查看在當前位置和限制位置之間是否有元素：
        while (buffer.hasRemaining()){
            // 讀取此緩沖區當前位置的整數，然後當前位置遞增。
            int j = buffer.get();
            System.out.print(j + " ");
        }
    }
}

public abstract class Buffer {
    // 三個字段屬性之間的數值關系：0 <= position <= limit <= capacity
    private int position = 0;
    private int limit;
    private int capacity;
    ...
}

/**
 * @author csp
 * @date 2021-11-26 4:09 下午
 */
public class BufferDemo {

    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("/Users/csp/IdeaProjects/netty-study/test.txt");

        // 創建文件的操作管道
        FileChannel channel = fileInputStream.getChannel();

        // 分配一個容量為10的緩沖區（本質上就是一個容量為10的byte數組）
        ByteBuffer buffer = ByteBuffer.allocate(10);

        output("初始化", buffer);
        channel.read(buffer);// 從管道將數據讀取到buffer容器中
        output("調用read()", buffer);

        // 準備操作之前，先鎖定操作范圍：
        buffer.flip();
        output("調用flip()", buffer);

        // 判斷有沒有可讀數據
        while (buffer.remaining() > 0){
            byte b = buffer.get();
        }
        output("調用get()", buffer);

        // 可以理解為解鎖
        buffer.clear();
        output("調用clear()", buffer);

        // 最後把管道關閉
        fileInputStream.close();
    }

    /**
     * 將緩沖區裡的實時狀態打印出來
     *
     * @param step
     * @param buffer
     */
    public static void output(String step, Buffer buffer) {
        System.out.println(step + " : ");
        // 容量（數組大小）：
        System.out.print("capacity" + buffer.capacity() + " , ");
        // 當前操作數據所在的位置，也可以叫做遊標：
        System.out.print("position" + buffer.position() + " , ");
        // 鎖定值，flip，數據操作范圍索引隻能在 position - limit 之間：
        System.out.println("limit" + buffer.limit());
        System.out.println();
    }
}

// 分配一個容量為10的緩沖區（本質上就是一個容量為10的byte數組）
ByteBuffer buffer = ByteBuffer.allocate(10);

// 從管道將數據讀取到buffer容器中 
channel.read(buffer);
output("調用read()", buffer);

// 準備操作之前，先鎖定操作范圍：
buffer.flip();
output("調用flip()", buffer);

// 判斷有沒有可讀數據
while (buffer.remaining() > 0){
    byte b = buffer.get();
}
output("調用get()", buffer);

// 可以理解為解鎖
buffer.clear();
output("調用clear()", buffer);

// 最後把管道關閉
fileInputStream.close();

// 位於ByteBuffer下
public static ByteBuffer allocate(int capacity) {
    if (capacity < 0)
        throw new IllegalArgumentException();
    // 新建一個ByteBuffer數組對象，容量為：capacity，limit參數值為：capacity
    return new HeapByteBuffer(capacity, capacity);
}

// 位於HeapByteBuffer下，父類為：ByteBuffer
HeapByteBuffer(int cap, int lim) {
    super(-1, 0, lim, cap, new byte[cap], 0);// 調用ByteBuffer的有參構造函數
}

// 位於ByteBuffer下，父類為：Buffer
ByteBuffer(int mark, int pos, int lim, int cap,
                 byte[] hb, int offset){
    super(mark, pos, lim, cap);// 調用 Buffer構造函數
    this.hb = hb;// final byte[] hb; 不可變的byte數組
    this.offset = offset;// 偏移量
}

// Buffer構造函數
Buffer(int mark, int pos, int lim, int cap) {
    if (cap < 0)
        throw new IllegalArgumentException("Negative capacity: " + cap);
    this.capacity = cap;// 數組容量
    limit(lim);// 數組的瞭limit
    position(pos);// 數組的positio
    if (mark >= 0) {
        if (mark > pos)
            throw new IllegalArgumentException("mark > position: ("
                                               + mark + " > " + pos + ")");
        this.mark = mark;
    }
}

// 初始化一個byte數組
byte[] bytes = new byte[10];
// 將該數組包裝給ByteBuffer
ByteBuffer buffer = ByteBuffer.wrap(bytes);

/**
 * @author csp
 * @date 2021-11-28 6:20 下午
 */
public class BufferSlice {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(10);

        // 向緩沖區中put數據: 0~9
        for (int i = 0; i < buffer.capacity(); i++) {
            buffer.put((byte) i);
        }

        // 創建子緩沖區：即從數組下標為3的位置到下標為7的位置
        buffer.position(3);
        buffer.limit(7);
        ByteBuffer slice = buffer.slice();

        // 改變子緩沖區的內容
        for (int i = 0; i < slice.capacity(); i++) {
            byte b = slice.get(i);
            b *= 10;
            slice.put(i, b);
        }

        // position和limit恢復到初始位置：
        buffer.position(0);
        buffer.limit(buffer.capacity());

        // 輸出buffer容器中的內容：
        while (buffer.hasRemaining()) {
            System.out.println(buffer.get());
        }
    }
}

/**
 * @author csp
 * @date 2021-11-28 6:33 下午
 */
public class ReadOnlyBuffer {
    public static void main(String[] args) {
        // 初始化一個容量為10的緩沖區
        ByteBuffer buffer = ByteBuffer.allocate(10);

        // 向緩沖區中put數據: 0~9
        for (int i = 0; i < buffer.capacity(); i++) {
            buffer.put((byte) i);
        }

        // 將該緩沖區轉變為隻讀緩沖區
        ByteBuffer readOnlyBuffer = buffer.asReadOnlyBuffer();

        // 由於buffer和readOnlyBuffer本質上共享一個byte[]數組對象，
        // 所以，改變buffer緩沖區的內容時，會導致隻讀緩沖區readOnlyBuffer的內容也隨著改變。
        for (int i = 0; i < buffer.capacity(); i++) {
            byte b = buffer.get(i);
            b *= 10;
            buffer.put(i, b);
        }

        // position和limit恢復到初始位置：
        readOnlyBuffer.position(0);
        readOnlyBuffer.limit(buffer.capacity());

        // 輸出readOnlyBuffer容器中的內容：
        while (readOnlyBuffer.hasRemaining()) {
            System.out.println(readOnlyBuffer.get());
        }
    }
}

/**
 * @author csp
 * @date 2021-11-28 7:07 下午
 */
public class DirectBuffer {
    public static void main(String[] args) throws IOException {
        // 從磁盤中讀取test.txt文件內容
        FileInputStream fileInputStream = new FileInputStream("/Users/csp/IdeaProjects/netty-study/test.txt");
        // 創建文件的操作管道
        FileChannel inputStreamChannel = fileInputStream.getChannel();

        // 把讀取的內容寫入到新的文件中
        FileOutputStream fileOutputStream = new FileOutputStream("/Users/csp/IdeaProjects/netty-study/test2.txt");
        FileChannel outputStreamChannel = fileOutputStream.getChannel();
        
        // 創建直接緩沖區
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(1024);
        
        while (true){
            byteBuffer.clear();

            int read = inputStreamChannel.read(byteBuffer);
            
            if (read == -1){
                break;
            }
            
            byteBuffer.flip();
            
            outputStreamChannel.write(byteBuffer);
        }
    }
}

/**
 * @author csp
 * @date 2021-11-28 7:16 下午
 */
public class MapperBuffer {
    static private final int start = 0;
    static private final int size = 10;

    public static void main(String[] args) throws IOException {
        RandomAccessFile randomAccessFile = new RandomAccessFile("/Users/csp/IdeaProjects/netty-study/test.txt", "rw");

        FileChannel channel = randomAccessFile.getChannel();

        // 把緩沖區跟文件系統進行一個映射關聯，隻要操作緩沖區裡面的內容，文件內容也會隨之改變
        MappedByteBuffer mappedByteBuffer = channel.map(FileChannel.MapMode.READ_WRITE, start, size);

        mappedByteBuffer.put(4, (byte) 97);// a
        mappedByteBuffer.put(5, (byte) 122);// z

        randomAccessFile.close();
    }
}