Java I/O體系從原理到應用，這一篇說清楚了
本文介紹操作系統(tǒng)I/O工作原理，Java I/O設計，基本使用，開源項目中實現(xiàn)高性能I/O常見方法和實現(xiàn)，徹底搞懂高性能I/O之道。
一、基礎概念
在介紹I/O原理之前，先重溫幾個基礎概念：
1. 操作系統(tǒng)與內核
操作系統(tǒng)：管理計算機硬件與軟件資源的系統(tǒng)軟件
內核：操作系統(tǒng)的核心軟件，負責管理系統(tǒng)的進程、內存、設備驅動程序、文件和網(wǎng)絡系統(tǒng)等等，為應用程序提供對計算機硬件的安全訪問服務
2. 內核空間和用戶空間
為了避免用戶進程直接操作內核，保證內核安全，操作系統(tǒng)將內存尋址空間劃分為兩部分：內核空間(Kernel-space)，供內核程序使用用戶空間(User-space)，供用戶進程使用 為了安全，內核空間和用戶空間是隔離的，即使用戶的程序崩潰了，內核也不受影響。
3. 數(shù)據(jù)流
計算機中的數(shù)據(jù)是基于隨著時間變換高低電壓信號傳輸?shù)模@些數(shù)據(jù)信號連續(xù)不斷，有著固定的傳輸方向，類似水管中水的流動，因此抽象數(shù)據(jù)流(I/O流)的概念：指一組有順序的、有起點和終點的字節(jié)集合，抽象出數(shù)據(jù)流的作用：實現(xiàn)程序邏輯與底層硬件解耦，通過引入數(shù)據(jù)流作為程序與硬件設備之間的抽象層，面向通用的數(shù)據(jù)流輸入輸出接口編程，而不是具體硬件特性，程序和底層硬件可以獨立靈活替換和擴展。
二、I/O 工作原理
1. 磁盤I/O
典型I/O讀寫磁盤工作原理如下：
tips: DMA：全稱叫直接內存存取(Direct Memory Access)，是一種允許外圍設備(硬件子系統(tǒng))直接訪問系統(tǒng)主內存的機制。基于 DMA 訪問方式，系統(tǒng)主內存與硬件設備的數(shù)據(jù)傳輸可以省去CPU 的全程調度。
值得注意的是：
- 讀寫操作基于系統(tǒng)調用實現(xiàn)
- 讀寫操作經(jīng)過用戶緩沖區(qū)，內核緩沖區(qū)，應用進程并不能直接操作磁盤
- 應用進程讀操作時需阻塞直到讀取到數(shù)據(jù)
2. 網(wǎng)絡I/O
這里先以最經(jīng)典的阻塞式I/O模型介紹：
tips:recvfrom，經(jīng)socket接收數(shù)據(jù)的函數(shù)
值得注意的是：
- 網(wǎng)絡I/O讀寫操作經(jīng)過用戶緩沖區(qū)，Sokcet緩沖區(qū)
- 服務端線程在從調用recvfrom開始到它返回有數(shù)據(jù)報準備好這段時間是阻塞的，recvfrom返回成功后，線程開始處理數(shù)據(jù)報
三、Java I/O設計
1. I/O分類
Java中對數(shù)據(jù)流進行具體化和實現(xiàn)，關于Java數(shù)據(jù)流一般關注以下幾個點：
- 流的方向從外部到程序，稱為輸入流;從程序到外部，稱為輸出流
- 流的數(shù)據(jù)單位程序以字節(jié)作為最小讀寫數(shù)據(jù)單元，稱為字節(jié)流，以字符作為最小讀寫數(shù)據(jù)單元，稱為字符流
- 流的功能角色
從/向一個特定的IO設備(如磁盤，網(wǎng)絡)或者存儲對象(如內存數(shù)組)讀/寫數(shù)據(jù)的流，稱為節(jié)點流;
對一個已有流進行連接和封裝，通過封裝后的流來實現(xiàn)數(shù)據(jù)的讀/寫功能，稱為處理流(或稱為過濾流)。
2. I/O操作接口
java.io包下有一堆I/O操作類，初學時看了容易搞不懂，其實仔細觀察其中還是有規(guī)律：這些I/O操作類都是在繼承4個基本抽象流的基礎上，要么是節(jié)點流，要么是處理流。
(1) 四個基本抽象流
java.io包中包含了流式I/O所需要的所有類，java.io包中有四個基本抽象流，分別處理字節(jié)流和字符流：
- InputStream
- OutputStream
- Reader
- Writer
(2) 節(jié)點流
節(jié)點流I/O類名由節(jié)點流類型 + 抽象流類型組成，常見節(jié)點類型有：
- File文件
- Piped 進程內線程通信管道
- ByteArray / CharArray (字節(jié)數(shù)組 / 字符數(shù)組)
- StringBuffer / String (字符串緩沖區(qū) / 字符串)
節(jié)點流的創(chuàng)建通常是在構造函數(shù)傳入數(shù)據(jù)源，例如：
- FileReader reader = new FileReader(new File("file.txt"));
- FileWriter writer = new FileWriter(new File("file.txt"));
(3) 處理流
處理流I/O類名由對已有流封裝的功能 + 抽象流類型組成，常見功能有：
- 緩沖：對節(jié)點流讀寫的數(shù)據(jù)提供了緩沖的功能，數(shù)據(jù)可以基于緩沖批量讀寫，提高效率。常見有BufferedInputStream、BufferedOutputStream
- 字節(jié)流轉換為字符流：由InputStreamReader、OutputStreamWriter實現(xiàn)
- 字節(jié)流與基本類型數(shù)據(jù)相互轉換：這里基本數(shù)據(jù)類型數(shù)據(jù)如int、long、short，由DataInputStream、DataOutputStream實現(xiàn)
- 字節(jié)流與對象實例相互轉換：用于實現(xiàn)對象序列化，由ObjectInputStream、ObjectOutputStream實現(xiàn)
處理流的應用了適配器/裝飾模式，轉換/擴展已有流，處理流的創(chuàng)建通常是在構造函數(shù)傳入已有的節(jié)點流或處理流：
- FileOutputStream fileOutputStream = new FileOutputStream("file.txt");
- // 擴展提供緩沖寫
- BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
- // 擴展提供提供基本數(shù)據(jù)類型寫
- DataOutputStream out = new DataOutputStream(bufferedOutputStream);
3. Java NIO
(1) 標準I/O存在問題
Java NIO(New I/O)是一個可以替代標準Java I/O API的IO API(從Java 1.4開始)，Java NIO提供了與標準I/O不同的I/O工作方式，目的是為了解決標準 I/O存在的以下問題：
A. 數(shù)據(jù)多次拷貝
標準I/O處理，完成一次完整的數(shù)據(jù)讀寫，至少需要從底層硬件讀到內核空間，再讀到用戶文件，又從用戶空間寫入內核空間，再寫入底層硬件。
此外，底層通過write、read等函數(shù)進行I/O系統(tǒng)調用時，需要傳入數(shù)據(jù)所在緩沖區(qū)起始地址和長度由于JVM GC的存在，導致對象在堆中的位置往往會發(fā)生移動，移動后傳入系統(tǒng)函數(shù)的地址參數(shù)就不是真正的緩沖區(qū)地址了。
可能導致讀寫出錯，為了解決上面的問題，使用標準I/O進行系統(tǒng)調用時，還會額外導致一次數(shù)據(jù)拷貝：把數(shù)據(jù)從JVM的堆內拷貝到堆外的連續(xù)空間內存(堆外內存)。
所以總共經(jīng)歷6次數(shù)據(jù)拷貝，執(zhí)行效率較低。
B. 操作阻塞
傳統(tǒng)的網(wǎng)絡I/O處理中，由于請求建立連接(connect)，讀取網(wǎng)絡I/O數(shù)據(jù)(read)，發(fā)送數(shù)據(jù)(send)等操作是線程阻塞的。
- // 等待連接
- Socket socket = serverSocket.accept();
- // 連接已建立，讀取請求消息
- StringBuilder req = new StringBuilder();
- byte[] recvByteBuf = new byte[1024];
- int len;
- while ((len = socket.getInputStream().read(recvByteBuf)) != -1) {
- req.append(new String(recvByteBuf, 0, len, StandardCharsets.UTF_8));
- }
- // 寫入返回消息
- socket.getOutputStream().write(("server response msg".getBytes()));
- socket.shutdownOutput();
以上面服務端程序為例，當請求連接已建立，讀取請求消息，服務端調用read方法時，客戶端數(shù)據(jù)可能還沒就緒(例如客戶端數(shù)據(jù)還在寫入中或者傳輸中)，線程需要在read方法阻塞等待直到數(shù)據(jù)就緒。
為了實現(xiàn)服務端并發(fā)響應，每個連接需要獨立的線程單獨處理，當并發(fā)請求量大時為了維護連接，內存、線程切換開銷過大。
(2) Buffer
Java NIO核心三大核心組件是Buffer(緩沖區(qū))、Channel(通道)、Selector。
Buffer提供了常用于I/O操作的字節(jié)緩沖區(qū)，常見的緩存區(qū)有ByteBuffer, CharBuffer, DoubleBuffer, FloatBuffer, IntBuffer, LongBuffer, ShortBuffer，分別對應基本數(shù)據(jù)類型: byte, char, double, float, int, long, short，下面介紹主要以最常用的ByteBuffer為例，Buffer底層支持Java堆外內存和堆內內存。
堆外內存是指與堆內存相對應的，把內存對象分配在JVM堆以外的內存，這些內存直接受操作系統(tǒng)管理(而不是虛擬機，相比堆內內存，I/O操作中使用堆外內存的優(yōu)勢在于：
- 不用被JVM GC線回收，減少GC線程資源占有
- 在I/O系統(tǒng)調用時，直接操作堆外內存，可以節(jié)省一次堆外內存和堆內內存的復制
ByteBuffer底層基于堆外內存的分配和釋放基于malloc和free函數(shù)，對外allocateDirect方法可以申請分配堆外內存，并返回繼承ByteBuffer類的DirectByteBuffer對象：
- public static ByteBuffer allocateDirect(int capacity) {
- return new DirectByteBuffer(capacity);
- }
堆外內存的回收基于DirectByteBuffer的成員變量Cleaner類，提供clean方法可以用于主動回收，Netty中大部分堆外內存通過記錄定位Cleaner的存在，主動調用clean方法來回收;另外，當DirectByteBuffer對象被GC時，關聯(lián)的堆外內存也會被回收。
tips：JVM參數(shù)不建議設置-XX:+DisableExplicitGC，因為部分依賴Java NIO的框架(例如Netty)在內存異常耗盡時，會主動調用System.gc()，觸發(fā)Full GC，回收DirectByteBuffer對象，作為回收堆外內存的最后保障機制，設置該參數(shù)之后會導致在該情況下堆外內存得不到清理。
堆外內存基于基礎ByteBuffer類的DirectByteBuffer類成員變量：Cleaner對象，這個Cleaner對象會在合適的時候執(zhí)行unsafe.freeMemory(address)，從而回收這塊堆外內存。
Buffer可以見到理解為一組基本數(shù)據(jù)類型，存儲地址連續(xù)的的數(shù)組，支持讀寫操作，對應讀模式和寫模式，通過幾個變量來保存這個數(shù)據(jù)的當前位置狀態(tài)：capacity、 position、 limit：
- capacity 緩沖區(qū)數(shù)組的總長度
- position 下一個要操作的數(shù)據(jù)元素的位置
- limit 緩沖區(qū)數(shù)組中不可操作的下一個元素的位置：limit <= capacity
(3) Channel
Channel(通道)的概念可以類比I/O流對象，NIO中I/O操作主要基于Channel：從Channel進行數(shù)據(jù)讀取 ：創(chuàng)建一個緩沖區(qū)，然后請求Channel讀取數(shù)據(jù) 從Channel進行數(shù)據(jù)寫入 ：創(chuàng)建一個緩沖區(qū)，填充數(shù)據(jù)，請求Channel寫入數(shù)據(jù)。
Channel和流非常相似，主要有以下幾點區(qū)別：
- Channel可以讀和寫，而標準I/O流是單向的
- Channel可以異步讀寫，標準I/O流需要線程阻塞等待直到讀寫操作完成
- Channel總是基于緩沖區(qū)Buffer讀寫
Java NIO中最重要的幾個Channel的實現(xiàn)：
- FileChannel：用于文件的數(shù)據(jù)讀寫，基于FileChannel提供的方法能減少讀寫文件數(shù)據(jù)拷貝次數(shù)，后面會介紹
- DatagramChannel：用于UDP的數(shù)據(jù)讀寫
- SocketChannel：用于TCP的數(shù)據(jù)讀寫，代表客戶端連接
- ServerSocketChannel：監(jiān)聽TCP連接請求，每個請求會創(chuàng)建會一個SocketChannel，一般用于服務端
基于標準I/O中，我們第一步可能要像下面這樣獲取輸入流，按字節(jié)把磁盤上的數(shù)據(jù)讀取到程序中，再進行下一步操作，而在NIO編程中，需要先獲取Channel，再進行讀寫。
- FileInputStream fileInputStream = new FileInputStream("test.txt");
- FileChannel channel = fileInputStream.channel();
tips: FileChannel僅能運行在阻塞模式下，文件異步處理的 I/O 是在JDK 1.7 才被加入的 java.nio.channels.AsynchronousFileChannel。
- // server socket channel:
- ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
- serverSocketChannel.bind(new InetSocketAddress(InetAddress.getLocalHost(), 9091));
- while (true) {
- SocketChannel socketChannel = serverSocketChannel.accept();
- ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
- int readBytes = socketChannel.read(buffer);
- if (readBytes > 0) {
- // 從寫數(shù)據(jù)到buffer翻轉為從buffer讀數(shù)據(jù)
- buffer.flip();
- byte[] bytes = new byte[buffer.remaining()];
- buffer.get(bytes);
- String body = new String(bytes, StandardCharsets.UTF_8);
- System.out.println("server 收到：" + body);
- }
- }
(4) Selector
Selector(選擇器) ，它是Java NIO核心組件中的一個，用于檢查一個或多個NIO Channel(通道)的狀態(tài)是否處于可讀、可寫。實現(xiàn)單線程管理多個Channel，也就是可以管理多個網(wǎng)絡連接。
Selector核心在于基于操作系統(tǒng)提供的I/O復用功能，單個線程可以同時監(jiān)視多個連接描述符，一旦某個連接就緒(一般是讀就緒或者寫就緒)，能夠通知程序進行相應的讀寫操作，常見有select、poll、epoll等不同實現(xiàn)。
Java NIO Selector基本工作原理如下：
- 初始化Selector對象，服務端ServerSocketChannel對象
- 向Selector注冊ServerSocketChannel的socket-accept事件
- 線程阻塞于selector.select()，當有客戶端請求服務端，線程退出阻塞
- 基于selector獲取所有就緒事件，此時先獲取到socket-accept事件，向Selector注冊客戶端SocketChannel的數(shù)據(jù)就緒可讀事件事件
- 線程再次阻塞于selector.select()，當有客戶端連接數(shù)據(jù)就緒，可讀
- 基于ByteBuffer讀取客戶端請求數(shù)據(jù)，然后寫入響應數(shù)據(jù)，關閉channel
示例如下，完整可運行代碼已經(jīng)上傳github(https://github.com/caison/caison-blog-demo)：
- Selector selector = Selector.open();
- ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
- serverSocketChannel.bind(new InetSocketAddress(9091));
- // 配置通道為非阻塞模式
- serverSocketChannel.configureBlocking(false);
- // 注冊服務端的socket-accept事件
- serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
- while (true) {
- // selector.select()會一直阻塞，直到有channel相關操作就緒
- selector.select();
- // SelectionKey關聯(lián)的channel都有就緒事件
- Iterator<SelectionKey> keyIterator = selector.selectedKeys().iterator();
- while (keyIterator.hasNext()) {
- SelectionKey key = keyIterator.next();
- // 服務端socket-accept
- if (key.isAcceptable()) {
- // 獲取客戶端連接的channel
- SocketChannel clientSocketChannel = serverSocketChannel.accept();
- // 設置為非阻塞模式
- clientSocketChannel.configureBlocking(false);
- // 注冊監(jiān)聽該客戶端channel可讀事件，并為channel關聯(lián)新分配的buffer
- clientSocketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocateDirect(1024));
- }
- // channel可讀
- if (key.isReadable()) {
- SocketChannel socketChannel = (SocketChannel) key.channel();
- ByteBuffer buf = (ByteBuffer) key.attachment();
- int bytesRead;
- StringBuilder reqMsg = new StringBuilder();
- while ((bytesRead = socketChannel.read(buf)) > 0) {
- // 從buf寫模式切換為讀模式
- buf.flip();
- int bufbufRemain = buf.remaining();
- byte[] bytes = new byte[bufRemain];
- buf.get(bytes, 0, bytesRead);
- // 這里當數(shù)據(jù)包大于byteBuffer長度，有可能有粘包/拆包問題
- reqMsg.append(new String(bytes, StandardCharsets.UTF_8));
- buf.clear();
- }
- System.out.println("服務端收到報文：" + reqMsg.toString());
- if (bytesRead == -1) {
- byte[] bytes = "[這是服務回的報文的報文]".getBytes(StandardCharsets.UTF_8);
- int length;
- for (int offset = 0; offset < bytes.length; offset += length) {
- length = Math.min(buf.capacity(), bytes.length - offset);
- buf.clear();
- buf.put(bytes, offset, length);
- buf.flip();
- socketChannel.write(buf);
- }
- socketChannel.close();
- }
- }
- // Selector不會自己從已selectedKeys中移除SelectionKey實例
- // 必須在處理完通道時自己移除 下次該channel變成就緒時，Selector會再次將其放入selectedKeys中
- keyIterator.remove();
- }
- }
tips: Java NIO基于Selector實現(xiàn)高性能網(wǎng)絡I/O這塊使用起來比較繁瑣，使用不友好，一般業(yè)界使用基于Java NIO進行封裝優(yōu)化，擴展豐富功能的Netty框架來優(yōu)雅實現(xiàn)。
四、高性能I/O優(yōu)化
下面結合業(yè)界熱門開源項目介紹高性能I/O的優(yōu)化。
1. 零拷貝
零拷貝(zero copy)技術，用于在數(shù)據(jù)讀寫中減少甚至完全避免不必要的CPU拷貝，減少內存帶寬的占用，提高執(zhí)行效率，零拷貝有幾種不同的實現(xiàn)原理，下面介紹常見開源項目中零拷貝實現(xiàn)。
(1) Kafka零拷貝
Kafka基于Linux 2.1內核提供，并在2.4 內核改進的的sendfile函數(shù) + 硬件提供的DMA Gather Copy實現(xiàn)零拷貝，將文件通過socket傳送。
函數(shù)通過一次系統(tǒng)調用完成了文件的傳送，減少了原來read/write方式的模式切換。同時減少了數(shù)據(jù)的copy, sendfile的詳細過程如下：
基本流程如下：
- 用戶進程發(fā)起sendfile系統(tǒng)調用
- 內核基于DMA Copy將文件數(shù)據(jù)從磁盤拷貝到內核緩沖區(qū)
- 內核將內核緩沖區(qū)中的文件描述信息(文件描述符，數(shù)據(jù)長度)拷貝到Socket緩沖區(qū)
- 內核基于Socket緩沖區(qū)中的文件描述信息和DMA硬件提供的Gather Copy功能將內核緩沖區(qū)數(shù)據(jù)復制到網(wǎng)卡
- 用戶進程sendfile系統(tǒng)調用完成并返回
相比傳統(tǒng)的I/O方式，sendfile + DMA Gather Copy方式實現(xiàn)的零拷貝，數(shù)據(jù)拷貝次數(shù)從4次降為2次，系統(tǒng)調用從2次降為1次，用戶進程上下文切換次數(shù)從4次變成2次DMA Copy，大大提高處理效率。
Kafka底層基于java.nio包下的FileChannel的transferTo：
- public abstract long transferTo(long position, long count, WritableByteChannel target)
transferTo將FileChannel關聯(lián)的文件發(fā)送到指定channel，當Comsumer消費數(shù)據(jù)，Kafka Server基于FileChannel將文件中的消息數(shù)據(jù)發(fā)送到SocketChannel。
A. RocketMQ零拷貝
RocketMQ基于mmap + write的方式實現(xiàn)零拷貝：mmap() 可以將內核中緩沖區(qū)的地址與用戶空間的緩沖區(qū)進行映射，實現(xiàn)數(shù)據(jù)共享，省去了將數(shù)據(jù)從內核緩沖區(qū)拷貝到用戶緩沖區(qū)。
- tmp_buf = mmap(file, len);
- write(socket, tmp_buf, len);
mmap + write 實現(xiàn)零拷貝的基本流程如下：
- 用戶進程向內核發(fā)起系統(tǒng)mmap調用
- 將用戶進程的內核空間的讀緩沖區(qū)與用戶空間的緩存區(qū)進行內存地址映射
- 內核基于DMA Copy將文件數(shù)據(jù)從磁盤復制到內核緩沖區(qū)
- 用戶進程mmap系統(tǒng)調用完成并返回
- 用戶進程向內核發(fā)起write系統(tǒng)調用
- 內核基于CPU Copy將數(shù)據(jù)從內核緩沖區(qū)拷貝到Socket緩沖區(qū)
- 內核基于DMA Copy將數(shù)據(jù)從Socket緩沖區(qū)拷貝到網(wǎng)卡
- 用戶進程write系統(tǒng)調用完成并返回
RocketMQ中消息基于mmap實現(xiàn)存儲和加載的邏輯寫在org.apache.rocketmq.store.MappedFile中，內部實現(xiàn)基于nio提供的java.nio.MappedByteBuffer，基于FileChannel的map方法得到mmap的緩沖區(qū)：
- // 初始化
- this.fileChannel = new RandomAccessFile(this.file, "rw").getChannel();
- thisthis.mappedByteBuffer = this.fileChannel.map(MapMode.READ_WRITE, 0, fileSize);
查詢CommitLog的消息時，基于mappedByteBuffer偏移量pos，數(shù)據(jù)大小size查詢：
- public SelectMappedBufferResult selectMappedBuffer(int pos, int size) {
- int readPosition = getReadPosition();
- // ...各種安全校驗
- // 返回mappedByteBuffer視圖
- ByteBuffer byteBuffer = this.mappedByteBuffer.slice();
- byteBuffer.position(pos);
- ByteBuffer byteBufferbyteBufferNew = byteBuffer.slice();
- byteBufferNew.limit(size);
- return new SelectMappedBufferResult(this.fileFromOffset + pos, byteBufferNew, size, this);
- }
tips: transientStorePoolEnable機制Java NIO mmap的部分內存并不是常駐內存，可以被置換到交換內存(虛擬內存)，RocketMQ為了提高消息發(fā)送的性能，引入了內存鎖定機制，即將最近需要操作的CommitLog文件映射到內存，并提供內存鎖定功能，確保這些文件始終存在內存中，該機制的控制參數(shù)就是transientStorePoolEnable。
因此，MappedFile數(shù)據(jù)保存CommitLog刷盤有2種方式：
- 開啟transientStorePoolEnable：寫入內存字節(jié)緩沖區(qū)(writeBuffer) -> 從內存字節(jié)緩沖區(qū)(writeBuffer)提交(commit)到文件通道(fileChannel) -> 文件通道(fileChannel) -> flush到磁盤
- 未開啟transientStorePoolEnable：寫入映射文件字節(jié)緩沖區(qū)(mappedByteBuffer) -> 映射文件字節(jié)緩沖區(qū)(mappedByteBuffer) -> flush到磁盤
RocketMQ 基于 mmap+write 實現(xiàn)零拷貝，適用于業(yè)務級消息這種小塊文件的數(shù)據(jù)持久化和傳輸 Kafka 基于 sendfile 這種零拷貝方式，適用于系統(tǒng)日志消息這種高吞吐量的大塊文件的數(shù)據(jù)持久化和傳輸。
tips: Kafka 的索引文件使用的是 mmap+write 方式，數(shù)據(jù)文件發(fā)送網(wǎng)絡使用的是 sendfile 方式。
B. Netty零拷貝
Netty 的零拷貝分為兩種：
- 基于操作系統(tǒng)實現(xiàn)的零拷貝，底層基于FileChannel的transferTo方法
- 基于Java 層操作優(yōu)化，對數(shù)組緩存對象(ByteBuf )進行封裝優(yōu)化，通過對ByteBuf數(shù)據(jù)建立數(shù)據(jù)視圖，支持ByteBuf 對象合并，切分，當?shù)讓觾H保留一份數(shù)據(jù)存儲，減少不必要拷貝
2. 多路復用
Netty中對Java NIO功能封裝優(yōu)化之后，實現(xiàn)I/O多路復用代碼優(yōu)雅了很多：
- // 創(chuàng)建mainReactor
- NioEventLoopGroup boosGroup = new NioEventLoopGroup();
- // 創(chuàng)建工作線程組
- NioEventLoopGroup workerGroup = new NioEventLoopGroup();
- final ServerBootstrap serverBootstrap = new ServerBootstrap();
- serverBootstrap
- // 組裝NioEventLoopGroup
- .group(boosGroup, workerGroup)
- // 設置channel類型為NIO類型
- .channel(NioServerSocketChannel.class)
- // 設置連接配置參數(shù)
- .option(ChannelOption.SO_BACKLOG, 1024)
- .childOption(ChannelOption.SO_KEEPALIVE, true)
- .childOption(ChannelOption.TCP_NODELAY, true)
- // 配置入站、出站事件handler
- .childHandler(new ChannelInitializer<NioSocketChannel>() {
- @Override
- protected void initChannel(NioSocketChannel ch) {
- // 配置入站、出站事件channel
- ch.pipeline().addLast(...);
- ch.pipeline().addLast(...);
- }
- });
- // 綁定端口
- int port = 8080;
- serverBootstrap.bind(port).addListener(future -> {
- if (future.isSuccess()) {
- System.out.println(new Date() + ": 端口[" + port + "]綁定成功!");
- } else {
- System.err.println("端口[" + port + "]綁定失敗!");
- }
- });
3. 頁緩存(PageCache)
頁緩存(PageCache)是操作系統(tǒng)對文件的緩存，用來減少對磁盤的 I/O 操作，以頁為單位的，內容就是磁盤上的物理塊，頁緩存能幫助程序對文件進行順序讀寫的速度幾乎接近于內存的讀寫速度，主要原因就是由于OS使用PageCache機制對讀寫訪問操作進行了性能優(yōu)化：
頁緩存讀取策略：當進程發(fā)起一個讀操作 (比如，進程發(fā)起一個 read() 系統(tǒng)調用)，它首先會檢查需要的數(shù)據(jù)是否在頁緩存中：
- 如果在，則放棄訪問磁盤，而直接從頁緩存中讀取
- 如果不在，則內核調度塊 I/O 操作從磁盤去讀取數(shù)據(jù)，并讀入緊隨其后的少數(shù)幾個頁面(不少于一個頁面，通常是三個頁面)，然后將數(shù)據(jù)放入頁緩存中
頁緩存寫策略：當進程發(fā)起write系統(tǒng)調用寫數(shù)據(jù)到文件中，先寫到頁緩存，然后方法返回。此時數(shù)據(jù)還沒有真正的保存到文件中去，Linux 僅僅將頁緩存中的這一頁數(shù)據(jù)標記為“臟”，并且被加入到臟頁鏈表中。
然后，由flusher 回寫線程周期性將臟頁鏈表中的頁寫到磁盤，讓磁盤中的數(shù)據(jù)和內存中保持一致，最后清理“臟”標識。在以下三種情況下，臟頁會被寫回磁盤：
- 空閑內存低于一個特定閾值
- 臟頁在內存中駐留超過一個特定的閾值時
- 當用戶進程調用 sync() 和 fsync() 系統(tǒng)調用時
RocketMQ中，ConsumeQueue邏輯消費隊列存儲的數(shù)據(jù)較少，并且是順序讀取，在page cache機制的預讀取作用下，Consume Queue文件的讀性能幾乎接近讀內存，即使在有消息堆積情況下也不會影響性能，提供了2種消息刷盤策略：
- 同步刷盤：在消息真正持久化至磁盤后RocketMQ的Broker端才會真正返回給Producer端一個成功的ACK響應
- 異步刷盤，能充分利用操作系統(tǒng)的PageCache的優(yōu)勢，只要消息寫入PageCache即可將成功的ACK返回給Producer端。消息刷盤采用后臺異步線程提交的方式進行，降低了讀寫延遲，提高了MQ的性能和吞吐量
Kafka實現(xiàn)消息高性能讀寫也利用了頁緩存，這里不再展開。
