2. 程式人生 > >Java核心（五）深入理解BIO、NIO、AIO

Java核心（五）深入理解BIO、NIO、AIO

阿新 • • 發佈：2018-12-03

導讀：本文你將獲取到：同/非同步 + 阻/非阻塞的效能區別；BIO、NIO、AIO 的區別；理解和實現 NIO 操作 Socket 時的多路複用；同時掌握 IO 最底層最核心的操作技巧。

BIO、NIO、AIO 的區別是什麼？

同/非同步、阻/非阻塞的區別是什麼？

檔案讀寫最優雅的實現方式是什麼？

NIO 如何實現多路複用功能？

帶著以上這幾個問題，讓我們一起進入IO的世界吧。

在開始之前，我們先來思考一個問題：我們經常所說的“IO”的全稱到底是什麼？

可能很多人看到這個問題和我一樣一臉懵逼，IO的全稱其實是：Input/Output的縮寫。

一、IO 介紹

我們通常所說的 BIO 是相對於 NIO 來說的，BIO 也就是 Java 開始之初推出的 IO 操作模組，BIO 是 BlockingIO 的縮寫，顧名思義就是阻塞 IO 的意思。

1.1 BIO、NIO、AIO的區別

  1. BIO 就是傳統的 java.io 包，它是基於流模型實現的，互動的方式是同步、阻塞方式，也就是說在讀入輸入流或者輸出流時，在讀寫動作完成之前，執行緒會一直阻塞在那裡，它們之間的呼叫時可靠的線性順序。它的有點就是程式碼比較簡單、直觀；缺點就是 IO 的效率和擴充套件性很低，容易成為應用效能瓶頸。
  2. NIO 是 Java 1.4 引入的 java.nio 包，提供了 Channel、Selector、Buffer 等新的抽象，可以構建多路複用的、同步非阻塞 IO 程式，同時提供了更接近作業系統底層高效能的資料操作方式。
  3. AIO 是 Java 1.7 之後引入的包，是 NIO 的升級版本，提供了非同步非堵塞的 IO 操作方式，所以人們叫它 AIO（Asynchronous IO），非同步 IO 是基於事件和回撥機制實現的，也就是應用操作之後會直接返回，不會堵塞在那裡，當後臺處理完成，作業系統會通知相應的執行緒進行後續的操作。

1.2 全面認識 IO

傳統的 IO 大致可以分為4種類型：

  • InputStream、OutputStream 基於位元組操作的 IO
  • Writer、Reader 基於字元操作的 IO
  • File 基於磁碟操作的 IO
  • Socket 基於網路操作的 IO

java.net 下提供的 Scoket 很多時候人們也把它歸為 同步阻塞 IO ,因為網路通訊同樣是 IO 行為。

java.io 下的類和介面很多，但大體都是 InputStream、OutputStream、Writer、Reader 的子集，所有掌握這4個類和File的使用，是用好 IO 的關鍵。

1.3 IO 使用

接下來看 InputStream、OutputStream、Writer、Reader 的繼承關係圖和使用示例。

1.3.1 InputStream 使用

繼承關係圖和類方法，如下圖：

InputStream 使用示例：

InputStream inputStream = new FileInputStream("D:\\log.txt");
byte[] bytes = new byte[inputStream.available()];
inputStream.read(bytes);
String str = new String(bytes, "utf-8");
System.out.println(str);
inputStream.close();

1.3.2 OutputStream 使用

繼承關係圖和類方法，如下圖：

OutputStream 使用示例：

OutputStream outputStream = new FileOutputStream("D:\\log.txt",true); // 引數二，表示是否追加，true=追加
outputStream.write("你好，老王".getBytes("utf-8"));
outputStream.close();

1.3.3 Writer 使用

Writer 繼承關係圖和類方法，如下圖：

Writer 使用示例：

Writer writer = new FileWriter("D:\\log.txt",true); // 引數二，是否追加檔案，true=追加
writer.append("老王，你好");
writer.close();

1.3.4 Reader 使用

Reader 繼承關係圖和類方法，如下圖：

Reader 使用示例：

Reader reader = new FileReader(filePath);
BufferedReader bufferedReader = new BufferedReader(reader);
StringBuffer bf = new StringBuffer();
String str;
while ((str = bufferedReader.readLine()) != null) {
    bf.append(str + "\n");
}
bufferedReader.close();
reader.close();
System.out.println(bf.toString());

二、同步、非同步、阻塞、非阻塞

上面說了很多關於同步、非同步、阻塞和非阻塞的概念，接下來就具體聊一下它們4個的含義，以及組合之後形成的效能分析。

2.1 同步與非同步

同步就是一個任務的完成需要依賴另外一個任務時，只有等待被依賴的任務完成後，依賴的任務才能算完成，這是一種可靠的任務序列。要麼成功都成功，失敗都失敗，兩個任務的狀態可以保持一致。而非同步是不需要等待被依賴的任務完成，只是通知被依賴的任務要完成什麼工作，依賴的任務也立即執行，只要自己完成了整個任務就算完成了。至於被依賴的任務最終是否真正完成，依賴它的任務無法確定，所以它是不可靠的任務序列。我們可以用打電話和發簡訊來很好的比喻同步與非同步操作。

2.2 阻塞與非阻塞

阻塞與非阻塞主要是從 CPU 的消耗上來說的，阻塞就是 CPU 停下來等待一個慢的操作完成 CPU 才接著完成其它的事。非阻塞就是在這個慢的操作在執行時 CPU 去幹其它別的事，等這個慢的操作完成時，CPU 再接著完成後續的操作。雖然表面上看非阻塞的方式可以明顯的提高 CPU 的利用率，但是也帶了另外一種後果就是系統的執行緒切換增加。增加的 CPU 使用時間能不能補償系統的切換成本需要好好評估。

2.3 同/異、阻/非堵塞 組合

同/異、阻/非堵塞的組合，有四種類型，如下表：

組合方式 效能分析
同步阻塞 最常用的一種用法，使用也是最簡單的，但是 I/O 效能一般很差，CPU 大部分在空閒狀態。
同步非阻塞 提升 I/O 效能的常用手段，就是將 I/O 的阻塞改成非阻塞方式，尤其在網路 I/O 是長連線，同時傳輸資料也不是很多的情況下，提升效能非常有效。 這種方式通常能提升 I/O 效能，但是會增加CPU 消耗，要考慮增加的 I/O 效能能不能補償 CPU 的消耗，也就是系統的瓶頸是在 I/O 還是在 CPU 上。
非同步阻塞 這種方式在分散式資料庫中經常用到，例如在網一個分散式資料庫中寫一條記錄，通常會有一份是同步阻塞的記錄，而還有兩至三份是備份記錄會寫到其它機器上，這些備份記錄通常都是採用非同步阻塞的方式寫 I/O。非同步阻塞對網路 I/O 能夠提升效率，尤其像上面這種同時寫多份相同資料的情況。
非同步非阻塞 這種組合方式用起來比較複雜，只有在一些非常複雜的分散式情況下使用，像叢集之間的訊息同步機制一般用這種 I/O 組合方式。如 Cassandra 的 Gossip 通訊機制就是採用非同步非阻塞的方式。它適合同時要傳多份相同的資料到叢集中不同的機器，同時資料的傳輸量雖然不大，但是卻非常頻繁。這種網路 I/O 用這個方式效能能達到最高。

三、優雅的檔案讀寫

Java 7 之前檔案的讀取是這樣的：

// 新增檔案
FileWriter fileWriter = new FileWriter(filePath, true);
fileWriter.write(Content);
fileWriter.close();

// 讀取檔案
FileReader fileReader = new FileReader(filePath);
BufferedReader bufferedReader = new BufferedReader(fileReader);
StringBuffer bf = new StringBuffer();
String str;
while ((str = bufferedReader.readLine()) != null) {
    bf.append(str + "\n");
}
bufferedReader.close();
fileReader.close();
System.out.println(bf.toString());

Java 7 引入了Files（java.nio包下）的，大大簡化了檔案的讀寫，如下：

// 寫入檔案（追加方式：StandardOpenOption.APPEND）
Files.write(Paths.get(filePath), Content.getBytes(StandardCharsets.UTF_8), StandardOpenOption.APPEND);

// 讀取檔案
byte[] data = Files.readAllBytes(Paths.get(filePath));
System.out.println(new String(data, StandardCharsets.UTF_8));

讀寫檔案都是一行程式碼搞定，沒錯這就是最優雅的檔案操作。

Files 下還有很多有用的方法，比如建立多層資料夾，寫法上也簡單了：

// 建立多（單）層目錄（如果不存在建立，存在不會報錯）
new File("D://a//b").mkdirs();

四、Socket 和 NIO 的多路複用

本節帶你實現最基礎的 Socket 的同時，同時會實現 NIO 多路複用，還有 AIO 中 Socket 的實現。

4.1 傳統的 Socket 實現

接下來我們將會實現一個簡單的 Socket，伺服器端只發給客戶端資訊，再由客戶端打印出來的例子，程式碼如下：

int port = 4343; //埠號
// Socket 伺服器端（簡單的傳送資訊）
Thread sThread = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            ServerSocket serverSocket = new ServerSocket(port);
            while (true) {
                // 等待連線
                Socket socket = serverSocket.accept();
                Thread sHandlerThread = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try (PrintWriter printWriter = new PrintWriter(socket.getOutputStream())) {
                            printWriter.println("hello world！");
                            printWriter.flush();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                });
                sHandlerThread.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
});
sThread.start();

// Socket 客戶端（接收資訊並列印）
try (Socket cSocket = new Socket(InetAddress.getLocalHost(), port)) {
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(cSocket.getInputStream()));
    bufferedReader.lines().forEach(s -> System.out.println("客戶端：" + s));
} catch (UnknownHostException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
}
  • 呼叫 accept 方法，阻塞等待客戶端連線；
  • 利用 Socket 模擬了一個簡單的客戶端，只進行連線、讀取和列印；

在 Java 中，執行緒的實現是比較重量級的，所以執行緒的啟動或者銷燬是很消耗伺服器的資源的，即使使用執行緒池來實現，使用上述傳統的 Socket 方式，當連線數極具上升也會帶來效能瓶頸，原因是執行緒的上線文切換開銷會在高併發的時候體現的很明顯，並且以上操作方式還是同步阻塞式的程式設計，效能問題在高併發的時候就會體現的尤為明顯。

以上的流程，如下圖：

4.2 NIO 多路複用

介於以上高併發的問題，NIO 的多路複用功能就顯得意義非凡了。

NIO 是利用了單執行緒輪詢事件的機制，通過高效地定位就緒的 Channel，來決定做什麼，僅僅 select 階段是阻塞的，可以有效避免大量客戶端連線時，頻繁執行緒切換帶來的問題，應用的擴充套件能力有了非常大的提高。

// NIO 多路複用
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(4, 4,
        60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
threadPool.execute(new Runnable() {
    @Override
    public void run() {
        try (Selector selector = Selector.open();
             ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();) {
            serverSocketChannel.bind(new InetSocketAddress(InetAddress.getLocalHost(), port));
            serverSocketChannel.configureBlocking(false);
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            while (true) {
                selector.select(); // 阻塞等待就緒的Channel
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    try (SocketChannel channel = ((ServerSocketChannel) key.channel()).accept()) {
                        channel.write(Charset.defaultCharset().encode("你好，世界"));
                    }
                    iterator.remove();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
});

// Socket 客戶端（接收資訊並列印）
try (Socket cSocket = new Socket(InetAddress.getLocalHost(), port)) {
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(cSocket.getInputStream()));
    bufferedReader.lines().forEach(s -> System.out.println("NIO 客戶端：" + s));
} catch (IOException e) {
    e.printStackTrace();
}
  • 首先，通過 Selector.open() 建立一個 Selector，作為類似排程員的角色；
  • 然後，建立一個 ServerSocketChannel，並且向 Selector 註冊，通過指定 SelectionKey.OP_ACCEPT，告訴排程員，它關注的是新的連線請求；
  • 為什麼我們要明確配置非阻塞模式呢？這是因為阻塞模式下，註冊操作是不允許的，會丟擲 IllegalBlockingModeException 異常；
  • Selector 阻塞在 select 操作，當有 Channel 發生接入請求，就會被喚醒；

下面的圖，可以有效的說明 NIO 複用的流程：

就這樣 NIO 的多路複用就大大提升了伺服器端響應高併發的能力。

4.3 AIO 版 Socket 實現

Java 1.7 提供了 AIO 實現的 Socket 是這樣的，如下程式碼：

// AIO執行緒複用版
Thread sThread = new Thread(new Runnable() {
    @Override
    public void run() {
        AsynchronousChannelGroup group = null;
        try {
            group = AsynchronousChannelGroup.withThreadPool(Executors.newFixedThreadPool(4));
            AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open(group).bind(new InetSocketAddress(InetAddress.getLocalHost(), port));
            server.accept(null, new CompletionHandler<AsynchronousSocketChannel, AsynchronousServerSocketChannel>() {
                @Override
                public void completed(AsynchronousSocketChannel result, AsynchronousServerSocketChannel attachment) {
                    server.accept(null, this); // 接收下一個請求
                    try {
                        Future<Integer> f = result.write(Charset.defaultCharset().encode("你好，世界"));
                        f.get();
                        System.out.println("服務端傳送時間：" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
                        result.close();
                    } catch (InterruptedException | ExecutionException | IOException e) {
                        e.printStackTrace();
                    }
                }

                @Override
                public void failed(Throwable exc, AsynchronousServerSocketChannel attachment) {
                }
            });
            group.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
});
sThread.start();

// Socket 客戶端
AsynchronousSocketChannel client = AsynchronousSocketChannel.open();
Future<Void> future = client.connect(new InetSocketAddress(InetAddress.getLocalHost(), port));
future.get();
ByteBuffer buffer = ByteBuffer.allocate(100);
client.read(buffer, null, new CompletionHandler<Integer, Void>() {
    @Override
    public void completed(Integer result, Void attachment) {
        System.out.println("客戶端列印：" + new String(buffer.array()));
    }

    @Override
    public void failed(Throwable exc, Void attachment) {
        exc.printStackTrace();
        try {
            client.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
});
Thread.sleep(10 * 1000);

五、總結

以上基本就是 IO 從 1.0 到目前版本（本文的版本）JDK 8 的核心使用操作了，可以看出來 IO 作為比較常用的基礎功能，發展變化的改動也很大，而且使用起來也越來越簡單了，IO 的操作也是比較好理解的，一個輸入一個輸出，掌握好了輸入輸出也就掌握好了 IO，Socket 作為網路互動的整合功能，顯然 NIO 的多路複用，給 Socket 帶來了更多的活力和選擇，使用者可以根據自己的實際場景選擇相應的程式碼策略。

當然本文的最後，也給各位看官大爺，附上了本文的示例程式碼：https://github.com/vipstone/java-core-example

六、參考文件

http://t.cn/EwUJvWA

https://www.ibm.com/developerworks/cn/java/j-lo-javaio/index.html

相關推薦

Java核心（五）深入理解BIO、NIO、AIO

導讀：本文你將獲取到：同/非同步 + 阻/非阻塞的效能區別；BIO、NIO、AIO 的區別；理解和實現 NIO 操作 Socket 時的多路複用；同時掌握 IO 最底層最核心的操作技巧。 BIO、NIO、AIO 的區別是什麼？ 同/非同步、阻/非阻塞的區別是什麼？ 檔案讀寫最優雅的實現方式是什

Java核心（二）深入理解執行緒池ThreadPool

本文你將獲得以下資訊： 執行緒池原始碼解讀 執行緒池執行流程分析 帶返回值的執行緒池實現 延遲執行緒池實現 為了方便讀者理解，本文會由淺入深，先從執行緒池的使用開始再延伸到原始碼解讀和原始碼分析等高階內容，讀者可根據自己的情況自主選擇閱讀順序和需要了解的章節。 一、執行緒池優點

深度學習基礎系列（五）| 深入理解交叉熵函式及其在tensorflow和keras中的實現

　　在統計學中，損失函式是一種衡量損失和錯誤（這種損失與“錯誤地”估計有關，如費用或者裝置的損失）程度的函式。假設某樣本的實際輸出為a，而預計的輸出為y，則y與a之間存在偏差，深度學習的目的即是通過不斷地訓練迭代，使得a越來越接近y，即 a - y →0，而訓練的本質就是尋找損失函式最小值的過程。 　　常見的

java核心（五）：堆內存、棧內存、直接內存

fifo 創建 inpu 申請 棧內存 先進先出 span size -a 一、什麽是堆內存、棧內存？ 　　Java把內存劃分成兩種：一種是堆內存，一種是棧內存。 　　堆：主要用於存儲實例化的對象，數組。由JVM動態分配內存空間。一個JVM只有一個堆內存，線程是可以共享數據

Kafka 系列（五）—— 深入理解 Kafka 副本機制

一、Kafka叢集 Kafka 使用 Zookeeper 來維護叢集成員 (brokers) 的資訊。每個 broker 都有一個唯一標識 broker.id，用於標識自己在叢集中的身份，可以在配置檔案 server.properties 中進行配置，或者由程式自動生成。下面是 Kafka brokers 叢

聊聊高並發（二十四）解析java.util.concurrent各個組件（六） 深入理解AQS（四）

sar 成功 通知 ati help write ng- ads 同步 近期總體過了下AQS的結構。也在網上看了一些講AQS的文章，大部分的文章都是泛泛而談。又一次看了下AQS的代碼，把一些新的要點拿出來說一說。 AQS是一個管程。提供了一個主要的同步器的

（轉載）深入理解java的接口和抽象類

final類 轉載 如何實現 靜態 參考 種類型 tar 發現 是否 本文轉自地址：http://www.cnblogs.com/dolphin0520/p/3811437.html 作者：海子 出處：http://www.cnblogs.com/dolphin0520/

java內存模型（二）深入理解java內存模型的系列好文

總結 nal href ola down 深入理解 ati markdown vol 深入理解java內存模型（一）——基礎深入理解java內存模型（二）——重排序深入理解java內存模型（三）——順序一致性深入理解java內存模型（四）——volatile深入理解java

Java併發專題（三）深入理解volatile關鍵字

前言 　　上一章節簡單介紹了執行緒安全以及最基礎的保證執行緒安全的方法，建議大家手敲程式碼去體會。這一章會提到volatile關鍵字，雖然看起來很簡單，但是想徹底搞清楚需要具備JMM、CPU快取模型的知識。不要小看這個關鍵字，它在整個併發包（concurrent包）使用的非常廣泛，掌握volatile關鍵字

（重點）深入理解Java分散式架構

什麼是分散式架構 分散式系統（distributed system）是建立在網路之上的軟體系統。 內聚性是指每一個數據庫分佈節點高度自治，有本地的資料庫管理系統。 透明性是指每一個數據庫分佈節點對使用者的應用來說都是透明的，看不出是本地還是遠端。 在分散式資料庫系統中，使用者感覺不到資料是分佈的，即使用者

Java核心（一）：Java平臺的理解

從事 Java 至今已有6年有餘，再次做一次溫習並記錄於此，記得對 Java 最直觀的印象就是它宣傳的 “Write once, run anywhere”，還是目前看已經有些過於形式主義的語法呢？你對於 Java 平臺到底瞭解到什麼程度？請你先停下來總結思考一

聊聊高併發（二十四）解析java.util.concurrent各個元件（六） 深入理解AQS（四）

最近整體過了下AQS的結構，也在網上看了一些講AQS的文章，大部分的文章都是泛泛而談。重新看了下AQS的程式碼，把一些新的要點拿出來說一說。 AQS是一個管程，提供了一個基本的同步器的能力，包含了一個狀態，修改狀態的原子操作，以及同步執行緒的一系列操作。它是CLHLock

java多執行緒（六）深入理解volitale關鍵字

一、java記憶體模型與多執行緒程式設計中的三個感念 1、原子性 原子性是指一些操作或者全都執行，要麼或者全都不執行，整個操作作為一個整體是不可分割的，例如，一個銀行中有兩個賬戶A，B，現在要從A賬戶中轉賬500元到B賬戶，那麼一共可以分為兩個步驟：

JAVA學習（五）

java學習 步驟 字符串 關系運算符 幫助 條件判斷 方式 -- lean 一、 調試 步驟1：設置斷點(不能在空白處設置斷點) 步驟2：啟動調試 步驟3：調試代碼（F6單步跳過）筆記本Fn+F6(F5) 步驟4：結束調試 掌握調試的好處？ 很清晰的看到，

java學習（五）java類繼承

author java學習 dex int demo [] color javac print 1.制作一個工具類的文檔 javadoc -d 目錄 -author -version arrayTool.java 實例： class arrayDemo {

java教程（五）SSH框架-配置

jar 集成 相同 onf -i ret 順序 cati lin 前言：從這篇博客開始我將繼續講述Java教程：SSH篇。主要內容環繞SSH框架分析與搭建，今天先簡介一下SSH的配置。 SSH配置順序是： spring-->hibern

shiro的源碼學習（四）-- 深入理解realm

instance his face 成功 返回 void exce gen 調用 IniRealm的類結構如下圖： 下面分析每個類： (1)Ream: 域的頂點，其代碼如下：securityManager會使驗證器來調用，驗證器通過Realm返回用戶信息，確定用戶是否登錄

java學習（五）--- 方法

ret img 技術分享 註意 不能 logs 必須 方法 類型 方法的定義 修飾符 返回值類型 方法名(參數類型 參數名){ ... 方法體 ... return 返回值; } 註意：非void方法必須有返回值 方法重載： 　　可以聲

Java基礎（五）

system -- 參考 ima pan turn 同名方法 ron 有一個 一、面向對象 　　面向對象 ： 就是一種編程思想 1、類和對象 　　類是指描述一類事物，或者看成是一個分類，可以把類看作構造對象的模板。 　　對象是指具體的個體（也叫實例-instance）。創建

Java Error（五）

integer .com sta 使用 span color bubuko ring ava 出錯結果如圖所示 代碼無打錯名字等問題，出錯原因，初學容器，使用Collection 時，忘記引入包。 import java.util.*; import java.