1. 程式人生 > >Java核心(五)深入理解BIO、NIO、AIO

Java核心(五)深入理解BIO、NIO、AIO

導讀:本文你將獲取到:同/非同步 + 阻/非阻塞的效能區別;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