1.IO的演進

 

1.Java IO 演進之路

本文圍繞着一下幾個問題

一、Java 中 BIO、NIO、AIO 之間的區別及應用場景。

二、阻塞(Block)與非阻塞(Non-Block)區別。

三、同步(Synchronization)和異步(Asynchronous)的區別。

 

1.1 幾個概念

1.1.1 阻塞(Block)和非阻塞(Non-Block)

阻塞和非阻塞是進程在訪問數據的時候，數據是否準備就緒的一種處理方式,當數據沒有準備的時候。

阻塞：每每須要等待緩衝區中的數據準備好事後才處理其餘的事情，不然一直等待在那裏。

非阻塞:當咱們的進程訪問咱們的數據緩衝區的時候，若是數據沒有準備好則直接返回，不會等待。若是數據已經 準備好，也直接返回。

1.1.2 同步(Synchronization)和異步(Asynchronous)

同步和異步都是基於應用程序和操做系統處理 IO 事件所採用的方式。好比同步：是應用程序要直接參與 IO 讀寫 的操做。異步：全部的 IO 讀寫交給操做系統去處理，應用程序只須要等待通知。

同步方式在處理 IO 事件的時候，必須阻塞在某個方法上面等待咱們的 IO 事件完成(阻塞 IO 事件或者經過輪詢 IO 事件的方式),對於異步來講，全部的 IO 讀寫都交給了操做系統。這個時候，咱們能夠去作其餘的事情，並不須要去完 成真正的 IO 操做，當操做完成 IO 後，會給咱們的應用程序一個通知。

同步 : 阻塞到 IO 事件，阻塞到 read 或則 write。這個時候咱們就徹底不能作本身的事情。讓讀寫方法加入到線 程裏面，而後阻塞線程來實現，對線程的性能開銷比較大。

1.2 BIO 與 NIO 對比

下表總結了 Java BIO(Block IO)和 NIO(Non-Block IO)之間的主要差異異。

 

IO模型	BIO	NIO
通訊	面向流(鄉村公路)	面向緩衝(高速公路，多路複用技術)
處理	阻塞 IO(多線程)	非阻塞 IO(反應堆 Reactor)
觸發	無	選擇器(輪詢機制)

 

1.2.1 面向流與面向緩衝

Java NIO 和 BIO 之間第一個最大的區別是，BIO 是面向流的，NIO 是面向緩衝區的。 Java BIO 面向流意味着每 次從流中讀一個或多個字節，直至讀取全部字節，它們沒有被緩存在任何地方。此外，它不能先後移動流中的數據。 若是須要先後移動從流中讀取的數據，須要先將它緩存到一個緩衝區。 Java NIO 的緩衝導向方法略有不一樣。數據讀取 到一個它稍後處理的緩衝區，須要時可在緩衝區中先後移動。這就增長了處理過程當中的靈活性。可是，還須要檢查是 否該緩衝區中包含全部您須要處理的數據。並且，需確保當更多的數據讀入緩衝區時，不要覆蓋緩衝區裏還沒有處理的 數據。

1.2.2 阻塞與非阻塞

Java BIO 的各類流是阻塞的。這意味着，當一個線程調用 read() 或 write()時，該線程被阻塞，直到有一些數據被 讀取，或數據徹底寫入。該線程在此期間不能再幹任何事情了。 Java NIO 的非阻塞模式，使一個線程從某通道發送請 求讀取數據，可是它僅能獲得目前可用的數據，若是目前沒有數據可用時，就什麼都不會獲取。而不是保持線程阻塞， 因此直至數據變的能夠讀取以前，該線程能夠繼續作其餘的事情。 非阻塞寫也是如此。一個線程請求寫入一些數據到 某通道，但不須要等待它徹底寫入，這個線程同時能夠去作別的事情。 線程一般將非阻塞 IO 的空閒時間用於在其它 通道上執行 IO 操做，因此一個單獨的線程如今能夠管理多個輸入和輸出通道（channel）。

1.2.3 選擇器的問世

Java NIO 的選擇器(Selector)容許一個單獨的線程來監視多個輸入通道，你能夠註冊多個通道使用一個選擇器，然 後使用一個單獨的線程來「選擇」通道：這些通道里已經有能夠處理的輸入，或者選擇已準備寫入的通道。這種選擇機制， 使得一個單獨的線程很容易來管理多個通道。

1.2.4 NIO 和 BIO 如何影響應用程序的設計

不管您選擇 BIO 或 NIO 工具箱，可能會影響您應用程序設計的如下幾個方面：

A.對 NIO 或 BIO 類的 API 調用。

B.數據處理邏輯。

C.用來處理數據的線程數。

1.API 調用

固然，使用 NIO 的 API 調用時看起來與使用 BIO 時有所不一樣，但這並不意外，由於並非僅從一個 InputStream 逐字節讀取，而是數據必須先讀入緩衝區再處理。

2.數據處理

使用純粹的 NIO 設計相較 BIO 設計，數據處理也受到影響。 在 BIO 設計中，咱們從 InputStream 或 Reader 逐字節讀取數據。假設你正在處理一基於行的文本數據流，例如：

有以下一段文本：

Name:Tom
Age:18
Email: tom@qq.com
Phone:13888888888

該文本行的流能夠這樣處理：

FileInputStream input = new FileInputStream("d://info.txt");
BufferedReader reader = new BufferedReader(new InputStreamReader(input));
String nameLine = reader.readLine();
String ageLine = reader.readLine();
String emailLine = reader.readLine();
String phoneLine = reader.readLine();

 

 

請注意處理狀態由程序執行多久決定。換句話說，一旦 reader.readLine()方法返回，你就知道確定文本行就已讀完， readline()阻塞直到整行讀完，這就是緣由。你也知道此行包含名稱；一樣，第二個 readline()調用返回的時候，你知道 這行包含年齡等。 正如你能夠看到，該處理程序僅在有新數據讀入時運行，並知道每步的數據是什麼。一旦正在運行

的線程已處理過讀入的某些數據，該線程不會再回退數據（大多如此）。下圖也說明了這條原則：

（Java BIO: 從一個阻塞的流中讀數據） 而一個 NIO 的實現會有所不一樣，下面是一個簡單的例子：

ByteBuffer buffer = ByteBuffer.allocate(48);
int bytesRead = inChannel.read(buffer);

注意第二行，從通道讀取字節到 ByteBuffer。當這個方法調用返回時，你不知道你所需的全部數據是否在緩衝區內。 你所知道的是，該緩衝區包含一些字節，這使得處理有點困難。 假設第一次 read(buffer)調用後，讀入緩衝區的數據只有半行，例如，「Name:An」，你能處理數據嗎？顯然不能， 須要等待，直到整行數據讀入緩存，在此以前，對數據的任何處理毫無心義。 因此，你怎麼知道是否該緩衝區包含足夠的數據能夠處理呢？好了，你不知道。發現的方法只能查看緩衝區中的 數據。其結果是，在你知道全部數據都在緩衝區裏以前，你必須檢查幾回緩衝區的數據。這不只效率低下，並且能夠 使程序設計方案雜亂不堪。例如：

ByteBuffer buffer = ByteBuffer.allocate(48);
int bytesRead = inChannel.read(buffer);
while(!bufferFull(bytesRead)) {
　　bytesRead = inChannel.read(buffer);
}

bufferFull()方法必須跟蹤有多少數據讀入緩衝區，並返回真或假，這取決於緩衝區是否已滿。換句話說，若是緩衝 區準備好被處理，那麼表示緩衝區滿了。

bufferFull()方法掃描緩衝區，但必須保持在 bufferFull()方法被調用以前狀態相同。若是沒有，下一個讀入緩衝區的 數據可能沒法讀到正確的位置。這是不可能的，但倒是須要注意的又一問題。 若是緩衝區已滿，它能夠被處理。若是它不滿，而且在你的實際案例中有意義，你或許能處理其中的部分數據。 可是許多狀況下並不是如此。下圖展現了「緩衝區數據循環就緒」：

3. 設置處理線程數

NIO 可以讓您只使用一個（或幾個）單線程管理多個通道（網絡鏈接或文件），但付出的代價是解析數據可能會比 從一個阻塞流中讀取數據更復雜。

若是須要管理同時打開的成千上萬個鏈接，這些鏈接每次只是發送少許的數據，例如聊天服務器，實現 NIO 的服 務器多是一個優點。一樣，若是你須要維持許多打開的鏈接到其餘計算機上，如 P2P 網絡中，使用一個單獨的線程 來管理你全部出站鏈接，多是一個優點。一個線程多個鏈接的設計方案如：

Java NIO: 單線程管理多個鏈接

若是你有少許的鏈接使用很是高的帶寬，一次發送大量的數據，也許典型的 IO 服務器實現可能很是契合。下圖說明了 一個典型的 IO 服務器設計：

Java BIO: 一個典型的 IO 服務器設計- 一個鏈接經過一個線程處理。

1.4 Java AIO 詳解

jdk1.7 (NIO2)纔是實現真正的異步 AIO、把 IO 讀寫操做徹底交給操做系統，學習了 linux epoll 模式，下面咱們來作一 些演示。

1.4.1 AIO（Asynchronous IO）基本原理

服務端:AsynchronousServerSocketChannel

客服端:AsynchronousSocketChannel

用戶處理器:CompletionHandler 接口,這個接口實現應用程序向操做系統發起 IO 請求,當完成後處理具體邏輯，不然作 本身該作的事情，

「真正」的異步IO須要操做系統更強的支持。在IO多路複用模型中，事件循環將文件句柄的狀態事件通知給用戶線程， 由用戶線程自行讀取數據、處理數據。而在異步IO模型中，當用戶線程收到通知時，數據已經被內核讀取完畢，並放 在了用戶線程指定的緩衝區內，內核在IO完成後通知用戶線程直接使用便可。異步IO模型使用了Proactor設計模式實 現了這一機制，以下圖所示：

1.4.2 AIO 初體驗

服務端代碼：

　　　　

package com.gupaoedu.vip.netty.io.aio;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousChannelGroup;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* AIO 服務端
*/
public class AIOServer {
　　private final int port;
　　public static void main(String args[]) {
　　　　int port = 8000;
　　　　new AIOServer(port);
　　}
　　public AIOServer(int port) {
　　　　this.port = port;
　　　　listen();
　　}
　　private void listen() {
　　　　try {
　　　　　　ExecutorService executorService = Executors.newCachedThreadPool();
　　　　　　AsynchronousChannelGroup threadGroup = AsynchronousChannelGroup.withCachedThreadPool(executorService, 1);
　　　　　　final AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open(threadGroup);
　　　　　　server.bind(new InetSocketAddress(port));
　　　　　　System.out.println("服務已啓動，監聽端口" + port);
　　　　　　server.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>(){
　　　　　　　　final ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
　　　　　　　　public void completed(AsynchronousSocketChannel result, Object attachment){
　　　　　　　　　　System.out.println("IO 操做成功，開始獲取數據");
　　　　　　　　　　try {
　　　　　　　　　　　　buffer.clear();
　　　　　　　　　　　　result.read(buffer).get();
　　　　　　　　　　　　buffer.flip();
　　　　　　　　　　　　result.write(buffer);
　　　　　　　　　　　　buffer.flip();
　　　　　　　　　　} catch (Exception e) {
　　　　　　　　　　　　System.out.println(e.toString());
　　　　　　　　　　} finally {
　　　　　　　　　　　　try {
　　　　　　　　　　　　　  result.close();
　　　　　　　　　　　　　　server.accept(null, this);
　　　　　　　　　　　　} catch (Exception e) {
　　　　　　　　　　　　 System.out.println(e.toString());
　　　　　　　　　　   }
　　　　　　　   　}
　　　　　　　　   System.out.println("操做完成");
　　　　      　}
　　　　　　　　@Override
　　　　　　　　public void failed(Throwable exc, Object attachment) {
　　　　　　　　　　System.out.println("IO 操做是失敗: " + exc);
　　　　　　　　}
　　　　　　});
　　　　　　try {
　　　　　　　　Thread.sleep(Integer.MAX_VALUE);
　　　　　　} catch (InterruptedException ex) {
　　　　　　　　System.out.println(ex);
　　　　　　}
　　　　} catch (IOException e) {
　　　　　　System.out.println(e);
　　　　}
　　}
}

客戶端代碼：

package com.gupaoedu.vip.netty.io.aio;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
/**
* AIO 客戶端
*/
public class AIOClient {
　　private final AsynchronousSocketChannel client;
　　public AIOClient() throws Exception{
　　　　client = AsynchronousSocketChannel.open();
　　}
　　public void connect(String host,int port)throws Exception{
　　　　client.connect(new InetSocketAddress(host,port),null,new CompletionHandler<Void,Void>() {
　　　　　　@Override
　　　　　　public void completed(Void result, Void attachment) {
　　　　　　　　try {
　　　　　　　　　　client.write(ByteBuffer.wrap("這是一條測試數據".getBytes())).get();
　　　　　　　　　　System.out.println("已發送至服務器");
　　　　　　　　} catch (Exception ex) {
　　　　　　　　　　ex.printStackTrace();
　　　　　　　　}
　　　　　　}
　　　　　　@Override
　　　　　　public void failed(Throwable exc, Void attachment) {
　　　　　　　　exc.printStackTrace();
　　　　　　}
　　　　});
　　　　final ByteBuffer bb = ByteBuffer.allocate(1024);
　　　　client.read(bb, null, new CompletionHandler<Integer,Object>(){
　　　　　　@Override
　　　　　　public void completed(Integer result, Object attachment) {
　　　　　　　　System.out.println("IO 操做完成" + result);
　　　　　　　　System.out.println("獲取反饋結果" + new String(bb.array()));
　　　　　　}
　　　　　　@Override
　　　　　　public void failed(Throwable exc, Object attachment) {
　　　　　　　　exc.printStackTrace();
　　　　　　}
　　　　});
　　　　try {
　　　　　　Thread.sleep(Integer.MAX_VALUE);
　　　　} catch (InterruptedException ex) {
　　　　　　System.out.println(ex);
　　　　}
　　}
　　public static void main(String args[])throws Exception{
　　　　new AIOClient().connect("localhost",8000);
　　}
}

 

執行結果：

服務端

客戶端

1.5 各 IO 模型對比與總結

最後再來一張表總結

屬性	同步阻塞 IO(BIO)	僞異步 IO	非阻塞 IO（NIO）	異步 IO(AIO)
客戶端數:IO 線程數	1:1	M:N(M>=N)	M:1	M:0
阻塞類型	阻塞	阻塞	非阻塞	非阻塞
同步	同步	同步	同步(多路複用)	異步
API 使用難度	簡單	簡單	複雜	通常
調試難度	簡單	簡單	複雜	複雜
可靠性	很是差	差	高	高
吞吐量	低	中	高	高