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

時間  2019-11-06
標籤 java 核心 深刻 理解 bio nio aio 欄目 Java 简体版
原文   原文鏈接

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

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

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

文件讀寫最優雅的實現方式是什麼？github

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

帶着以上這幾個問題，讓咱們一塊兒進入IO的世界吧。編程

在開始以前，咱們先來思考一個問題：咱們常常所說的「IO」的全稱究竟是什麼？服務器

可能不少人看到這個問題和我同樣一臉懵逼，IO的全稱實際上是：Input/Output的縮寫。網絡

1、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種類型：app

  • 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());

2、同步、異步、阻塞、非阻塞

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

2.1 同步與異步

同步就是一個任務的完成須要依賴另一個任務時，只有等待被依賴的任務完成後，依賴的任務才能算完成，這是一種可靠的任務序列。要麼成功都成功，失敗都失敗，兩個任務的狀態能夠保持一致。而異步是不須要等待被依賴的任務完成，只是通知被依賴的任務要完成什麼工做，依賴的任務也當即執行，只要本身完成了整個任務就算完成了。至於被依賴的任務最終是否真正完成，依賴它的任務沒法肯定，因此它是不可靠的任務序列。咱們能夠用打電話和發短信來很好的比喻同步與異步操做。

2.2 阻塞與非阻塞

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

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

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

<table><tr style="font-weight:bold;"><td width="120">組合方式</td><td>性能分析</td></tr><tr><td>同步阻塞</td><td>最經常使用的一種用法，使用也是最簡單的，可是 I/O 性能通常不好，CPU 大部分在空閒狀態。</td></tr><tr><td>同步非阻塞</td><td>提高 I/O 性能的經常使用手段，就是將 I/O 的阻塞改爲非阻塞方式，尤爲在網絡 I/O 是長鏈接，同時傳輸數據也不是不少的狀況下，提高性能很是有效。 這種方式一般能提高 I/O 性能，可是會增長CPU 消耗，要考慮增長的 I/O 性能能不能補償 CPU 的消耗，也就是系統的瓶頸是在 I/O 仍是在 CPU 上。</td></tr><tr><td>異步阻塞</td><td>這種方式在分佈式數據庫中常常用到，例如在網一個分佈式數據庫中寫一條記錄，一般會有一份是同步阻塞的記錄，而還有兩至三份是備份記錄會寫到其它機器上，這些備份記錄一般都是採用異步阻塞的方式寫 I/O。異步阻塞對網絡 I/O 可以提高效率，尤爲像上面這種同時寫多份相同數據的狀況。</td></tr><tr><td>異步非阻塞</td><td>這種組合方式用起來比較複雜，只有在一些很是複雜的分佈式狀況下使用，像集羣之間的消息同步機制通常用這種 I/O 組合方式。如 Cassandra 的 Gossip 通訊機制就是採用異步非阻塞的方式。它適合同時要傳多份相同的數據到集羣中不一樣的機器，同時數據的傳輸量雖然不大，可是卻很是頻繁。這種網絡 I/O 用這個方式性能能達到最高。</td></tr></table>

3、優雅的文件讀寫

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();

4、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);

5、總結

以上基本就是 IO 從 1.0 到目前版本（本文的版本）JDK 8 的核心使用操做了，能夠看出來 IO 做爲比較經常使用的基礎功能，發展變化的改動也很大，並且使用起來也愈來愈簡單了，IO 的操做也是比較好理解的，一個輸入一個輸出，掌握好了輸入輸出也就掌握好了 IO，Socket 做爲網絡交互的集成功能，顯然 NIO 的多路複用，給 Socket 帶來了更多的活力和選擇，用戶能夠根據本身的實際場景選擇相應的代碼策略。

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

6、參考文檔

http://t.cn/EwUJvWA

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

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程