IO那些事

IO（Input\Output): 即輸入輸出，通常指資料在存盤器（內部和外部）或其他周邊設備之間的輸入和輸出，是資訊處理系統（例如計算機）與外部世界（可能是人類或另一資訊處理系統）之間的通信，說的簡單點就是與外部設備（比如磁盤）傳輸資料，


IO大致可以分為磁盤IO、網路IO、記憶體IO，通常所說的IO指的是前兩者，本文將簡單介紹Linux的五大IO模型，java中的IO模型，并對java的NIO做一個基本介紹，

IO基本流程

外圍設備的直接讀寫涉及到中斷，中斷時需要保存行程資料、狀態等資訊、中斷結束后需要恢復行程資料和狀態，這種成本是比較高的，因此出現了一個叫內核緩沖區（位于內核空間）的東西，我們的程式并不是直接與IO設備互動的，而是與這個內核緩沖區互動，

如圖所示，讀的時候，先將資料從磁盤或者網卡拷貝到內核緩沖區（這一步是作業系統內核通過讀中斷完成的），然后從內核緩沖區拷貝到行程緩沖區（位于用戶空間）

寫的時候，先將資料寫到行程緩沖區，然后拷貝到內核緩沖區，然后寫到網卡或者刷到磁盤（這一步是通過寫中斷完成的），

讀中斷和寫中斷何時進行是內核決定的，大多數的IO操作并沒有實際的IO，而是在行程緩沖區與內核緩沖區來回拷貝資料，

一個完整的讀流程包括兩個階段：

1. 準備資料：將資料從網卡拷貝到內核緩沖區
2. 拷貝資料：將資料從內核緩沖區復制到行程緩沖區

兩個重要的名詞

• 同步與異步：同步就是用戶空間是發起IO的一方，異步是內核空間是發起IO的一方，也可以理解為同步就是自己要去查IO狀態，異步是內核可以通知你
• 阻塞與非阻塞：阻塞就是當你呼叫了一個IO讀或者寫時，需要等內核操作徹底(準備與拷貝資料)完成后才能回傳，這一段時間用戶空間程式是“卡住的狀態”；非阻塞就是，呼叫了一個讀或寫時不管內核有沒有操作完成，都會立即回傳，

五大IO模型

同步阻塞

這個模型印證了上述對同步與異步、阻塞與非阻塞的解釋，內核準備和拷貝資料的程序中，用戶空間程式一直阻塞，所以是阻塞；用戶空間是發起io的一方，所以是同步，

同步非阻塞

同步非阻塞的特點就是在資料準備階段發起io呼叫會立即回傳一個錯誤，用戶空間需要輪詢發起IO呼叫，在資料從內核緩沖區拷貝到行程緩沖區階段的呼叫仍然是會被阻塞的，這種模型需要一直輪詢IO狀態，用的比較少，

IO多路復用

在IO多路復用模型中，引入了一種新的系統呼叫，查詢IO的就緒狀態，在Linux系統中，對應的系統呼叫為select/epoll系統呼叫，通過該系統呼叫，一個行程可以監視多個檔案描述符，一旦某個描述符就緒（一般是內核緩沖區可讀/可寫），內核能夠將就緒的狀態回傳給應用程式，隨后，應用程式根據就緒的狀態，進行相應的IO系統呼叫，

————來自《Netty、Redis、Zookeeper高并發實戰》

相比于同步阻塞模型，這種模型的優勢在于一個執行緒能處理大量的IO連接，而同步阻塞只能靠開很多執行緒來處理多個IO連接，對于大量的IO連接無能為力，

如果連接數少的話，同步阻塞并不一定比IO多路復用性能差，因為IO多路復用有兩個系統呼叫，同步阻塞只有一個，

信號驅動

這種IO模型用的不多，java里邊找不到對應實作，信號驅動式模型的一個顯著特點就是用戶態行程不再等待內核態的資料準備好，直接可以去做別的事情，但是等待資料從內核緩沖區拷貝到行程緩沖區仍然是阻塞的，

異步IO(AIO)

上述幾種IO模型本質上都是同步IO，就算是信號驅動，他在資料從內核緩沖區拷貝到行程緩沖區也是阻塞的，

AIO的基本流程是：用戶執行緒通過系統呼叫，向內核注冊某個IO操作，內核在整個IO操作（包括資料準備、資料復制）完成后，通知用戶程式，用戶執行后續的業務操作.

這種IO模型是完美的IO模型，但是據說Linux支持的不太好，大名鼎鼎的netty也是使用的多路復用IO模型，還沒有使用AIO，

java中的IO

BIO

BIO就是Blocking IO, 對應上面說的同步阻塞IO模型，我們常使用的各種InputStream, 這種Reader，以及在網路編程用到的ServerSocket/Socket都是BIO，以一個Socket程式為例來直觀感受一下這種模型，

這兩段代碼分別展示一個tcp服務端和客戶端，實作的功能就是客戶端從本地讀一個檔案發送給服務端，服務端將收到的檔案寫入磁盤，

服務端的read方法的呼叫是阻塞的，這意味著這個服務端同一時刻只能處理一個連接，這顯然不合理，為了解決這個問題，我們可以考慮多執行緒機制，主執行緒只負責接受連接，收到連接就丟進其他執行緒進行處理，可以每次都開一個執行緒，也可以考慮使用執行緒池，如下的代碼實作了這個想法，

NIO

NIO，可以說是java中的新IO（New IO), 也可以叫None-Blocking IO, 他對應的是前文提到的多路復用IO模型，

NIO包括三個核心成員，Buffer、Channel、Selector, 后文會做詳細介紹，

這里簡單對比一下NIO和BIO：

上邊BIO的例子可以看到BIO是面向流的，NIO是面向緩沖區的，可以任務他的資料是一塊一塊的，通過后文的例子可以更清楚的看到這一點，

BIO都是阻塞的，也是就內核在準備資料拷貝資料階段，用戶空間發起IO的行程沒法干別的事，NIO是可以是非阻塞的，他可以通過注冊你感興趣的事件（比如可讀）到Selector中，然后干別的事（比如接收新的連接），當收到相應事件后再做處理，

NIO有一個通道的概念，既可以向通道里寫資料也可以從里邊讀，但是BIO就不行，只能從輸入流里邊讀資料，不能寫；也只能往輸出流寫資料，而不能從里邊讀，

AIO

對應前文提到的異步IO模型，這種模型支持不太好，JAVA AIO框架在windows下使用windows IOCP技術，在Linux下使用epoll多路復用IO技術模擬異步IO，鼎鼎大名的netty也沒有使用AIO，所以這里也不去深入探究了，

NIO基礎詳解

Buffer

Buffer是一個抽象類，可以認為是一個裝資料的容器，底層是陣列，他有很多子類：

例如：

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

使用最多的是ByteBuffer

Buffer的基本結構如下：

這幾個屬性的含義是必須要搞清楚的，這里簡單列舉，后文討論Buffer的基本操作會做進一步說明，

• position: 表示當前正在讀的位置
• limit: 表示可以讀取或者寫入的上限位置，只有小于這個值的位置才是有效的
• capacity: 容量，不是位元組數，而是能裝幾個資料，與每個資料占用的位元組數無關，創建時確定，不能再改變
• mark: 一個標記位置，可以方便的回到這個位置

buffer的基本操作：

• put(): 向緩沖區存資料
• get(): 從緩沖區取資料
• flip(): 切換到讀取資料的模式
• rewind()：position回到起始位置，可以重復讀
• clear()： 清慷訓沖區，但是資料仍然存在，limit，position回到最初狀態
• hasRemaining()：判斷是否還有資料可以讀
• remaining()：剩余幾個資料可以讀
• mark():標記當前操作的位置
• reset(): 回到之前標記的位置

我們直接通過一個demo來說明這些操作:

輸出如下：

創建后：
position=0,capacity=10,limit=10
寫入一個資料后：
position=2,capacity=10,limit=10
切換為讀模式后：
position=0,capacity=10,limit=2
讀取一個資料:1
position=1,capacity=10,limit=2
呼叫rewind:
position=0,capacity=10,limit=2
再次讀一個資料：
position=1,capacity=10,limit=2
呼叫Buffer.clear后
position=0,capacity=10,limit=10

通過這個測驗可以看出各種操作的基本使用及其對Buffer幾個屬性的影響，

直接緩沖區與非直接緩沖區：

• 非直接緩沖區：通過allocate()分配的緩沖區，將緩沖區建立在jvm的記憶體中
• 直接緩沖區：通過allocateDirect()分配的緩沖區，將緩沖區建立在物理記憶體中，zero copy
• 可以通過isDirect()判斷是否是直接緩沖區

Channel

NIO中的一個連接用一個通道表示，通道本身并不存放資料，只能與Buffer互動，

常見的通道：

1. FileChannel: 用于讀寫檔案的通道
2. SocketChannel：用于Socket套接字TCP連接的資料讀寫
3. ServerSocketChannel：允許我們監聽TCP連接請求，為每個監聽到的請求，創建一個SocketChannel套接字通道
4. DatagramChannel：用于UDP協議的資料讀寫

通道的獲取方法：

1. 通過支持通道的類的getChannel方法

本地io：

• FileInputStream
• FileOutputStream
• RandomAccessFile

fileInputStream.getChannel();

網路io：

• Socket
• ServerSocket
• DatagramSocket

socket.getChannel();

2. 使用各個通道的靜態方法open()獲取，jdk>=1.7

FileChannel fileChannel = FileChannel.open(Paths.get("a.jpg"), StandardOpenOption.READ);

3. 使用Files的newByteChannel()獲取，jdk>=1.7

SeekableByteChannel byteChannel = Files.newByteChannel(Paths.get("a.jpg"), StandardOpenOption.WRITE);

通道的基本操作

1. 讀：將通道里的資料讀到buffer里，回傳值表示讀取到的資料個數，回傳0表示沒有了，此方法還有幾個多載

public int read(ByteBuffer dst) throws IOException

2. 寫: 將buffer寫入通道，也有幾個多載

 public int write(ByteBuffer src) throws IOException

3. 獲取當前通道的大小，單位byte

public abstract long size() throws IOException

4. 將一個通道的資料發送到另一個通道

public long transferTo(long position, long count,
                                    WritableByteChannel target)
        throws IOException;

5. 上述反向

public long transferFrom(ReadableByteChannel src,
                                      long position, long count)
        throws IOException;

6. 關閉通道

public final void close() throws IOException

此外還有記憶體映射檔案、鎖相關內容，限于篇幅，此處不再展開，之后可能專門寫一篇探討，

Selector

我們可以將一個通道注冊到Selector中，并且指定你感興趣的事件（可以是多個，中間用|），通過不斷呼叫select選擇IO就緒事件，在發生相應事件時會得到一個通知，做后續處理，

選擇器的使命是完成IO的多路復用，一個通道代表一條連接通路，通過選擇器可以同時監控多個通道的IO（輸入輸出）狀況，選擇器和通道的關系，是監控和被監控的關系，

這里還涉及到SelectionKey的概念，SelectionKey選擇鍵就是那些被選擇器選中的IO事件，

主要方法：

1. 打開一個Selector

public static Selector open() throws IOException

2. 獲取SelectionKey

public Set<SelectionKey> selectedKeys();

3. 選擇感興趣的IO就緒事件

1. public int select(long timeout)
        throws IOException;
2. public int select() throws IOException;

4. 關閉Selector

public void close() throws IOException;

NIO涉及的概念和API較多，下面通過一個具體的例子簡單演示（移除了例外處理、關閉通道或連接的操作）

IO事件：

• （1）可讀：SelectionKey.OP_READ
• （2）可寫：SelectionKey.OP_WRITE
• （3）連接：SelectionKey.OP_CONNECT
• （4）接收：SelectionKey.OP_ACCEPT

并不是所有Channel都支持這幾個事件，例如ServerSocketChannel只支持OP_ACCEPT

一個NIO傳檔案的例子

/**
    * 移除了一些關閉通道的代碼，可能無法運行
    * 正常應該在try finally關閉， 或者使用try with resources語法自動關閉
    * @throws IOException
    */
@Test
public void server() throws IOException {
    // 獲得channel
    ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    // 系結埠
    serverSocketChannel.bind(new InetSocketAddress(1234));
    // 設定為非阻塞，這很重要!!!
    serverSocketChannel.configureBlocking(false);
    // 打開Selector
    Selector selector = Selector.open();
    // 將通道注冊到Selector
    serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
    int i = 0;
    while (selector.select() > 0) { // 輪詢選擇感興趣的io事件
        // 拿到選擇鍵
        Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
        while (iterator.hasNext()) { // 遍歷選擇鍵，對特定時間做處理， 可以單獨去開執行緒處理
            SelectionKey key = iterator.next();
            if (key.isAcceptable()) { // 處理接收事件
                ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
                SelectableChannel channel = serverChannel.accept();
                channel.configureBlocking(false);
                // 將客戶端連接的SocketChannel也進行注冊
                channel.register(selector, SelectionKey.OP_READ);
            } else if (key.isReadable()) { // 處理讀事件
                ByteBuffer buffer = ByteBuffer.allocate(1 * mb);
                SocketChannel clientChannel = (SocketChannel) key.channel();
                FileChannel fileChannel = FileChannel.open(Paths.get(path, "qrcode" + (++i) + ".png"),
                        StandardOpenOption.WRITE, StandardOpenOption.CREATE);
                int len = -1;
                while ((len = clientChannel.read(buffer)) > 0) {
                    buffer.flip(); // 切換到讀模式
                    fileChannel.write(buffer);
                    buffer.clear(); // 切回寫模式，別忘了！！
                }
                clientChannel.close();
                fileChannel.close();
            }
            // 處理過的事件一定要移除
            iterator.remove();
        }
    }
}

@Test
public void client() throws IOException {
    // 獲取channel
    SocketChannel socketChannel = SocketChannel.open();
    // 連接
    socketChannel.connect(new InetSocketAddress(1234));
    // 設定非阻塞
    socketChannel.configureBlocking(false);
    // 開選擇器
    Selector selector = Selector.open();
    // 將channel注冊進選擇器
    socketChannel.register(selector, SelectionKey.OP_WRITE);
    while (selector.select() > 0) { // 選擇感興趣的事件
        Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
        while (iterator.hasNext()) {
            SelectionKey key = iterator.next();
            SocketChannel channel = (SocketChannel) key.channel();
            if (key.isWritable()) { // 處理可寫事件
                FileChannel fileChannel = FileChannel.open(Paths.get(path, "qrcode.png"), StandardOpenOption.READ);
                ByteBuffer byteBuffer = ByteBuffer.allocate(1 * mb);
                int len = -1;
                while ((len = fileChannel.read(byteBuffer)) > 0) {
                    byteBuffer.flip();
                    channel.write(byteBuffer);
                    byteBuffer.clear();
                }
            }
        }
    }
}

NIO使用步驟總結

1. 獲取Channel
2. 打開Selector
3. 將channel注冊到Selector
4. 輪詢感興趣的事件
5. 遍歷SelectionKey并最不同事件型別做相應處理

NIO的難度確實比BIO高不少，而且上述只是一個簡單的例子，而且可能存在問題，實際中會比這里復雜的多，比如粘包拆包、序列化之類的問題，正因如此，才有了Netty，Netty有非常廣泛的應用，比如Dubbo底層、RocketMQ等等，Netty是后邊需要和大家一起研究的話題，

小結

本文介紹了5種IO模型，同步阻塞、同步非阻塞、多路復用、信號驅動、異步；然后介紹了java中的三種IO模型；最后對NIO的基礎支持點做了簡單介紹，期望能幫助你復習或者了解相關知識點，疏漏之處，請不吝指出，IO之路，道阻且長，加油~

參考資料

• 《Netty、Redis、Zookeeper高并發實戰》
• https://yasinshaw.com/articles/52
• https://www.bilibili.com/video/BV14W411u7ro?p=1

標籤：Java

上一篇：3、Spring Boot日志

下一篇：Java面試基本問題