面試官：BIO、NIO、AIO之間有什么區(qū)別？
一、簡(jiǎn)介
在計(jì)算機(jī)中，IO 傳輸數(shù)據(jù)有三種工作方式，分別是： BIO、NIO、AIO。
在講解 BIO、NIO、AIO 之前，我們先來(lái)回顧一下這幾個(gè)概念：同步與異步，阻塞與非阻塞。
同步與異步的區(qū)別
- 同步就是發(fā)起一個(gè)請(qǐng)求后，接受者未處理完請(qǐng)求之前，不返回結(jié)果。
- 異步就是發(fā)起一個(gè)請(qǐng)求后，立刻得到接受者的回應(yīng)表示已接收到請(qǐng)求，但是接受者并沒(méi)有處理完，接受者通常依靠事件回調(diào)等機(jī)制來(lái)通知請(qǐng)求者其處理結(jié)果。
阻塞和非阻塞的區(qū)別
- 阻塞就是請(qǐng)求者發(fā)起一個(gè)請(qǐng)求，一直等待其請(qǐng)求結(jié)果返回，也就是當(dāng)前線程會(huì)被掛起，無(wú)法從事其他任務(wù)，只有當(dāng)條件就緒才能繼續(xù)。
- 非阻塞就是請(qǐng)求者發(fā)起一個(gè)請(qǐng)求，不用一直等著結(jié)果返回，可以先去干其他事情，當(dāng)條件就緒的時(shí)候，就自動(dòng)回來(lái)。
而我們要講的 BIO、NIO、AIO 就是同步與異步、阻塞與非阻塞的組合。
- BIO：同步阻塞 IO；
- NIO：同步非阻塞 IO；
- AIO：異步非阻塞 IO;
不同的工作方式，帶來(lái)的傳輸效率是不一樣的，下面我們以網(wǎng)絡(luò) IO 為例，一起看看不同的工作方式下，彼此之間有何不同。
二、BIO
BIO 俗稱同步阻塞 IO，是一種非常傳統(tǒng)的 IO 模型，也是最常用的網(wǎng)絡(luò)數(shù)據(jù)傳輸處理方式，優(yōu)點(diǎn)就是編程簡(jiǎn)單，但是缺點(diǎn)也很明顯，I/O 傳輸性能一般比較差，CPU 大部分處于空閑狀態(tài)。
采用 BIO 通信模型的服務(wù)端，通常由一個(gè)獨(dú)立的 Acceptor 線程負(fù)責(zé)監(jiān)聽(tīng)所有客戶端的連接，當(dāng)服務(wù)端接受到多個(gè)客戶端的請(qǐng)求時(shí)，所有的客戶端只能排隊(duì)等待服務(wù)端一個(gè)一個(gè)的處理。
BIO 通信模型圖如下！
圖片
一般在服務(wù)端通過(guò)while(true)循環(huán)中會(huì)調(diào)用accept() 方法監(jiān)聽(tīng)客戶端的連接，一旦接收到一個(gè)連接請(qǐng)求，就可以建立通信套接字進(jìn)行讀寫(xiě)操作，此時(shí)不能再接收其他客戶端連接請(qǐng)求，只能等待同當(dāng)前連接的客戶端的操作執(zhí)行完成。
服務(wù)端操作，樣例程序如下：
public class BioServerTest {
public static void main(String[] args) throws IOException {
//初始化服務(wù)端socket并且綁定 8080 端口
ServerSocket serverSocket = new ServerSocket(8080);
//循環(huán)監(jiān)聽(tīng)客戶端請(qǐng)求
while (true){
try {
//監(jiān)聽(tīng)客戶端請(qǐng)求
Socket socket = serverSocket.accept();
//將字節(jié)流轉(zhuǎn)化成字符流，讀取客戶端輸入的內(nèi)容
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
//讀取一行數(shù)據(jù)
String str = bufferedReader.readLine();
//打印客戶端發(fā)送的信息
System.out.println("服務(wù)端收到客戶端發(fā)送的信息：" + str);
//向客戶端返回信息，將字符轉(zhuǎn)化成字節(jié)流，并輸出
PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()),true);
printWriter.println("hello，我是服務(wù)端，已收到消息");
// 關(guān)閉流
bufferedReader.close();
printWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}客戶端操作，樣例程序如下：
public class BioClientTest {
public static void main(String[] args) {
//創(chuàng)建10個(gè)線程，模擬10個(gè)客戶端，同時(shí)向服務(wù)端發(fā)送請(qǐng)求
for (int i = 0; i < 10; i++) {
final int j = i;//定義變量
new Thread(new Runnable() {
@Override
public void run() {
try {
//通過(guò)IP和端口與服務(wù)端建立連接
Socket socket =new Socket("127.0.0.1",8080);
//將字符流轉(zhuǎn)化成字節(jié)流，并輸出
PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()),true);
String str="Hello，我是" + j + "個(gè)，客戶端!";
printWriter.println(str);
//從輸入流中讀取服務(wù)端返回的信息，將字節(jié)流轉(zhuǎn)化成字符流
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
//讀取內(nèi)容
String result = bufferedReader.readLine();
//打印服務(wù)端返回的信息
System.out.println("客戶端發(fā)送請(qǐng)求內(nèi)容：" + str + " -> 收到服務(wù)端返回的內(nèi)容：" + result);
// 關(guān)閉流
bufferedReader.close();
printWriter.close();
// 關(guān)閉socket
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}).start();
}
}
}最后，依次啟動(dòng)服務(wù)端、客戶端，看看控制臺(tái)輸出情況如何。
服務(wù)端控制臺(tái)結(jié)果如下：
服務(wù)端收到客戶端發(fā)送的信息：Hello，我是8個(gè)，客戶端!
服務(wù)端收到客戶端發(fā)送的信息：Hello，我是9個(gè)，客戶端!
服務(wù)端收到客戶端發(fā)送的信息：Hello，我是7個(gè)，客戶端!
服務(wù)端收到客戶端發(fā)送的信息：Hello，我是5個(gè)，客戶端!
服務(wù)端收到客戶端發(fā)送的信息：Hello，我是4個(gè)，客戶端!
服務(wù)端收到客戶端發(fā)送的信息：Hello，我是3個(gè)，客戶端!
服務(wù)端收到客戶端發(fā)送的信息：Hello，我是6個(gè)，客戶端!
服務(wù)端收到客戶端發(fā)送的信息：Hello，我是2個(gè)，客戶端!
服務(wù)端收到客戶端發(fā)送的信息：Hello，我是1個(gè)，客戶端!
服務(wù)端收到客戶端發(fā)送的信息：Hello，我是0個(gè)，客戶端!客戶端控制臺(tái)結(jié)果如下：
客戶端發(fā)送請(qǐng)求內(nèi)容：Hello，我是8個(gè)，客戶端! -> 收到服務(wù)端返回的內(nèi)容：hello，我是服務(wù)端，已收到消息
客戶端發(fā)送請(qǐng)求內(nèi)容：Hello，我是9個(gè)，客戶端! -> 收到服務(wù)端返回的內(nèi)容：hello，我是服務(wù)端，已收到消息
客戶端發(fā)送請(qǐng)求內(nèi)容：Hello，我是7個(gè)，客戶端! -> 收到服務(wù)端返回的內(nèi)容：hello，我是服務(wù)端，已收到消息
客戶端發(fā)送請(qǐng)求內(nèi)容：Hello，我是5個(gè)，客戶端! -> 收到服務(wù)端返回的內(nèi)容：hello，我是服務(wù)端，已收到消息
客戶端發(fā)送請(qǐng)求內(nèi)容：Hello，我是4個(gè)，客戶端! -> 收到服務(wù)端返回的內(nèi)容：hello，我是服務(wù)端，已收到消息
客戶端發(fā)送請(qǐng)求內(nèi)容：Hello，我是3個(gè)，客戶端! -> 收到服務(wù)端返回的內(nèi)容：hello，我是服務(wù)端，已收到消息
客戶端發(fā)送請(qǐng)求內(nèi)容：Hello，我是6個(gè)，客戶端! -> 收到服務(wù)端返回的內(nèi)容：hello，我是服務(wù)端，已收到消息
客戶端發(fā)送請(qǐng)求內(nèi)容：Hello，我是2個(gè)，客戶端! -> 收到服務(wù)端返回的內(nèi)容：hello，我是服務(wù)端，已收到消息
客戶端發(fā)送請(qǐng)求內(nèi)容：Hello，我是1個(gè)，客戶端! -> 收到服務(wù)端返回的內(nèi)容：hello，我是服務(wù)端，已收到消息
客戶端發(fā)送請(qǐng)求內(nèi)容：Hello，我是0個(gè)，客戶端! -> 收到服務(wù)端返回的內(nèi)容：hello，我是服務(wù)端，已收到消息隨著客戶端的請(qǐng)求次數(shù)越來(lái)越多，可能需要排隊(duì)的時(shí)間會(huì)越來(lái)越長(zhǎng)，因此是否可以在服務(wù)端，采用多線程編程進(jìn)行處理呢？
答案是，可以的！
下面我們對(duì)服務(wù)端的代碼進(jìn)行改造，服務(wù)端多線程操作，樣例程序如下：
public class BioServerTest {
public static void main(String[] args) throws IOException {
//初始化服務(wù)端socket并且綁定 8080 端口
ServerSocket serverSocket = new ServerSocket(8080);
//循環(huán)監(jiān)聽(tīng)客戶端請(qǐng)求
while (true){
//監(jiān)聽(tīng)客戶端請(qǐng)求
Socket socket = serverSocket.accept();
new Thread(new Runnable() {
@Override
public void run() {
try {
String threadName = Thread.currentThread().toString();
//將字節(jié)流轉(zhuǎn)化成字符流，讀取客戶端輸入的內(nèi)容
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
//讀取一行數(shù)據(jù)
String str = bufferedReader.readLine();
//打印客戶端發(fā)送的信息
System.out.println("線程名稱" + threadName + "，服務(wù)端收到客戶端發(fā)送的信息：" + str);
//向客戶端返回信息，將字符轉(zhuǎn)化成字節(jié)流，并輸出
PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()),true);
printWriter.println("hello，我是服務(wù)端，已收到消息");
// 關(guān)閉流
bufferedReader.close();
printWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}).start();
}
}
}依次啟動(dòng)服務(wù)端、客戶端，服務(wù)端控制臺(tái)輸出結(jié)果如下：
線程名稱Thread[Thread-8,5,main]，服務(wù)端收到客戶端發(fā)送的信息：Hello，我是4個(gè)，客戶端!
線程名稱Thread[Thread-4,5,main]，服務(wù)端收到客戶端發(fā)送的信息：Hello，我是8個(gè)，客戶端!
線程名稱Thread[Thread-0,5,main]，服務(wù)端收到客戶端發(fā)送的信息：Hello，我是1個(gè)，客戶端!
線程名稱Thread[Thread-7,5,main]，服務(wù)端收到客戶端發(fā)送的信息：Hello，我是5個(gè)，客戶端!
線程名稱Thread[Thread-5,5,main]，服務(wù)端收到客戶端發(fā)送的信息：Hello，我是2個(gè)，客戶端!
線程名稱Thread[Thread-9,5,main]，服務(wù)端收到客戶端發(fā)送的信息：Hello，我是3個(gè)，客戶端!
線程名稱Thread[Thread-1,5,main]，服務(wù)端收到客戶端發(fā)送的信息：Hello，我是0個(gè)，客戶端!
線程名稱Thread[Thread-3,5,main]，服務(wù)端收到客戶端發(fā)送的信息：Hello，我是7個(gè)，客戶端!
線程名稱Thread[Thread-2,5,main]，服務(wù)端收到客戶端發(fā)送的信息：Hello，我是9個(gè)，客戶端!
線程名稱Thread[Thread-6,5,main]，服務(wù)端收到客戶端發(fā)送的信息：Hello，我是6個(gè)，客戶端!當(dāng)服務(wù)端接收到客戶端的請(qǐng)求時(shí)，會(huì)給每個(gè)客戶端創(chuàng)建一個(gè)新的線程進(jìn)行鏈路處理，處理完成之后，通過(guò)輸出流返回應(yīng)答給客戶端，最后線程會(huì)銷毀。
但是這樣的編程模型也有很大的弊端，如果出現(xiàn) 100、1000、甚至 10000 個(gè)客戶端同時(shí)請(qǐng)求服務(wù)端，采用這種編程模型，服務(wù)端也會(huì)創(chuàng)建與之相同的線程數(shù)量，線程數(shù)急劇膨脹可能會(huì)導(dǎo)致線程堆棧溢出、創(chuàng)建新線程失敗等問(wèn)題，最終可能導(dǎo)致服務(wù)端宕機(jī)或者僵死，不能對(duì)外提供服務(wù)。
三、偽異步 BIO
為了解決上面提到的同步阻塞 I/O 面臨的一個(gè)鏈路需要一個(gè)線程處理的問(wèn)題，后來(lái)有人對(duì)它的編程模型進(jìn)行了優(yōu)化。
在服務(wù)端通過(guò)使用 Java 中ThreadPoolExecutor線程池機(jī)制來(lái)處理多個(gè)客戶端的請(qǐng)求接入，防止由于海量并發(fā)接入導(dǎo)致資源耗盡，讓線程的創(chuàng)建和回收成本相對(duì)較低，保證了系統(tǒng)有限的資源得以控制，實(shí)現(xiàn)了 N （客戶端請(qǐng)求數(shù)量）大于 M （服務(wù)端處理客戶端請(qǐng)求的線程數(shù)量）的偽異步 I/O 模型。
偽異步 IO 模型圖，如下圖：
圖片
采用線程池和任務(wù)隊(duì)列可以實(shí)現(xiàn)一種叫做偽異步的 I/O 通信框架，當(dāng)有新的客戶端接入時(shí)，將客戶端的 Socket 封裝成一個(gè) Task 投遞到線程池中進(jìn)行處理。
服務(wù)端采用線程池處理客戶端請(qǐng)求，樣例程序如下：
public class BioServerTest {
public static void main(String[] args) throws IOException {
//在線程池中創(chuàng)建5個(gè)固定大小線程，來(lái)處理客戶端的請(qǐng)求
ExecutorService executorService = Executors.newFixedThreadPool(5);
//初始化服務(wù)端socket并且綁定 8080 端口
ServerSocket serverSocket = new ServerSocket(8080);
//循環(huán)監(jiān)聽(tīng)客戶端請(qǐng)求
while (true){
//監(jiān)聽(tīng)客戶端請(qǐng)求
Socket socket = serverSocket.accept();
//使用線程池執(zhí)行任務(wù)
executorService.execute(new Runnable() {
@Override
public void run() {
try {
String threadName = Thread.currentThread().toString();
//將字節(jié)流轉(zhuǎn)化成字符流，讀取客戶端輸入的內(nèi)容
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
//讀取一行數(shù)據(jù)
String str = bufferedReader.readLine();
//打印客戶端發(fā)送的信息
System.out.println("線程名稱" + threadName + "，服務(wù)端收到客戶端發(fā)送的信息：" + str);
//向客戶端返回信息，將字符轉(zhuǎn)化成字節(jié)流，并輸出
PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()),true);
printWriter.println("hello，我是服務(wù)端，已收到消息");
// 關(guān)閉流
bufferedReader.close();
printWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
});
}
}
}依次啟動(dòng)服務(wù)端、客戶端，服務(wù)端控制臺(tái)輸出結(jié)果如下：
線程名稱Thread[pool-1-thread-4,5,main]，服務(wù)端收到客戶端發(fā)送的信息：Hello，我是6個(gè)，客戶端!
線程名稱Thread[pool-1-thread-2,5,main]，服務(wù)端收到客戶端發(fā)送的信息：Hello，我是8個(gè)，客戶端!
線程名稱Thread[pool-1-thread-3,5,main]，服務(wù)端收到客戶端發(fā)送的信息：Hello，我是9個(gè)，客戶端!
線程名稱Thread[pool-1-thread-5,5,main]，服務(wù)端收到客戶端發(fā)送的信息：Hello，我是5個(gè)，客戶端!
線程名稱Thread[pool-1-thread-1,5,main]，服務(wù)端收到客戶端發(fā)送的信息：Hello，我是7個(gè)，客戶端!
線程名稱Thread[pool-1-thread-5,5,main]，服務(wù)端收到客戶端發(fā)送的信息：Hello，我是2個(gè)，客戶端!
線程名稱Thread[pool-1-thread-5,5,main]，服務(wù)端收到客戶端發(fā)送的信息：Hello，我是0個(gè)，客戶端!
線程名稱Thread[pool-1-thread-1,5,main]，服務(wù)端收到客戶端發(fā)送的信息：Hello，我是1個(gè)，客戶端!
線程名稱Thread[pool-1-thread-5,5,main]，服務(wù)端收到客戶端發(fā)送的信息：Hello，我是3個(gè)，客戶端!
線程名稱Thread[pool-1-thread-1,5,main]，服務(wù)端收到客戶端發(fā)送的信息：Hello，我是4個(gè)，客戶端!本例中測(cè)試的客戶端數(shù)量是 10，服務(wù)端使用 java 線程池來(lái)處理任務(wù)，線程數(shù)量為 5 個(gè)，服務(wù)端不用為每個(gè)客戶端都創(chuàng)建一個(gè)線程，由于線程池可以設(shè)置消息隊(duì)列的大小和最大線程數(shù)，因此它的資源占用是可控的，無(wú)論多少個(gè)客戶端并發(fā)訪問(wèn)，都不會(huì)導(dǎo)致資源的耗盡和宕機(jī)。
在活動(dòng)連接數(shù)不是特別高的情況下，這種模型還是不錯(cuò)的，可以讓每一個(gè)連接專注于自己的 I/O 并且編程模型簡(jiǎn)單，也不用過(guò)多考慮系統(tǒng)的過(guò)載、限流等問(wèn)題。
但是，它的底層仍然是同步阻塞的 BIO 模型，當(dāng)面對(duì)十萬(wàn)甚至百萬(wàn)級(jí)請(qǐng)求接入的時(shí)候，傳統(tǒng)的 BIO 模型無(wú)能為力，因此我們需要一種更高效的 I/O 處理模型來(lái)應(yīng)對(duì)更高的并發(fā)量。
四、NIO
NIO，英文全稱：Non-blocking-IO，一種同步非阻塞的 I/O 模型。
在 Java 1.4 中引入，對(duì)應(yīng)的代碼在java.nio包下。
與傳統(tǒng)的 IO 不同，NIO 新增了 Channel、Selector、Buffer 等抽象概念，支持面向緩沖、基于通道的 I/O 數(shù)據(jù)傳輸方法。
NIO 模型圖，如下圖：
圖片
與此同時(shí)，NIO 還提供了與傳統(tǒng) BIO 模型中的 Socket 和 ServerSocket 相對(duì)應(yīng)的 SocketChannel 和 ServerSocketChannel 兩種不同的套接字通道實(shí)現(xiàn)。
NIO 這兩種通道都支持阻塞和非阻塞兩種模式。阻塞模式使用就像傳統(tǒng)中的 BIO 一樣，比較簡(jiǎn)單，但是性能和可靠性都不好；非阻塞模式正好與之相反。
對(duì)于低負(fù)載、低并發(fā)的應(yīng)用程序，可以使用同步阻塞 I/O 來(lái)提升開(kāi)發(fā)效率和更好的維護(hù)性；對(duì)于高負(fù)載、高并發(fā)的（網(wǎng)絡(luò)）應(yīng)用，使用 NIO 的非阻塞模式來(lái)開(kāi)發(fā)可以顯著的提升數(shù)據(jù)傳輸效率。
在介紹樣例之前，我們先看一下 NIO 涉及到的核心關(guān)聯(lián)類圖，如下：
圖片
上圖中有三個(gè)關(guān)鍵類：Channel 、Selector 和 Buffer，它們是 NIO 中的核心概念。
- Channel：可以理解為通道；
- Selector：可以理解為選擇器；
- Buffer：可以理解為數(shù)據(jù)緩沖區(qū)；
從名詞上看感覺(jué)很抽象，我們還是用之前介紹的城市交通工具來(lái)繼續(xù)形容 NIO 的工作方式，這里的 Channel 要比 Socket 更加具體，它可以比作為某種具體的交通工具，如汽車或是高鐵、飛機(jī)等，而 Selector 可以比作為一個(gè)車站的車輛運(yùn)行調(diào)度系統(tǒng)，它將負(fù)責(zé)監(jiān)控每輛車的當(dāng)前運(yùn)行狀態(tài)，是已經(jīng)出站還是在路上等等，也就是說(shuō)它可以輪詢每個(gè) Channel 的狀態(tài)。
還有一個(gè) Buffer 類，你可以將它看作為 IO 中 Stream，但是它比 IO 中的 Stream 更加具體化，我們可以將它比作為車上的座位，Channel 如果是汽車的話，那么 Buffer 就是汽車上的座位，Channel 如果是高鐵上，那么 Buffer 就是高鐵上的座位，它始終是一個(gè)具體的概念，這一點(diǎn)與 Stream 不同。
Socket 中的 Stream 只能代表是一個(gè)座位，至于是什么座位由你自己去想象，也就是說(shuō)你在上車之前并不知道這個(gè)車上是否還有座位，也不知道上的是什么車，因?yàn)槟悴⒉荒苓x擇，這些信息都已經(jīng)被封裝在了運(yùn)輸工具（Socket）里面了。
NIO 引入了 Channel、Buffer 和 Selector 就是想把 IO 傳輸過(guò)程中涉及到的信息具體化，讓程序員有機(jī)會(huì)去控制它們。
當(dāng)我們進(jìn)行傳統(tǒng)的網(wǎng)絡(luò) IO 操作時(shí)，比如調(diào)用write()往 Socket 中的SendQ隊(duì)列寫(xiě)數(shù)據(jù)時(shí)，當(dāng)一次寫(xiě)的數(shù)據(jù)超過(guò)SendQ長(zhǎng)度時(shí)，操作系統(tǒng)會(huì)按照SendQ 的長(zhǎng)度進(jìn)行分割的，這個(gè)過(guò)程中需要將用戶空間數(shù)據(jù)和內(nèi)核地址空間進(jìn)行切換，而這個(gè)切換不是程序員可以控制的，由底層操作系統(tǒng)來(lái)幫我們處理。
而在Buffer中，我們可以控制Buffer的capacity（容量），并且是否擴(kuò)容以及如何擴(kuò)容都可以控制。
理解了這些概念后我們看一下，實(shí)際上它們是如何工作的呢？
我們一起來(lái)看看代碼實(shí)例！
服務(wù)端操作，樣例程序如下：
/**
* NIO 服務(wù)端
*/
public class NioServerTest {
public static void main(String[] args) throws IOException {
// 打開(kāi)服務(wù)器套接字通道
ServerSocketChannel ssc = ServerSocketChannel.open();
// 服務(wù)器配置為非阻塞
ssc.configureBlocking(false);
// 進(jìn)行服務(wù)的綁定，監(jiān)聽(tīng)8080端口
ssc.socket().bind(new InetSocketAddress(8080));
// 構(gòu)建一個(gè)Selector選擇器,并且將channel注冊(cè)上去
Selector selector = Selector.open();
// 將serverSocketChannel注冊(cè)到selector,并對(duì)accept事件感興趣(serverSocketChannel只能支持accept操作)
ssc.register(selector, SelectionKey.OP_ACCEPT);
while (true){
// 查詢指定事件已經(jīng)就緒的通道數(shù)量，select方法有阻塞效果,直到有事件通知才會(huì)有返回，如果為0就跳過(guò)
int readyChannels = selector.select();
if(readyChannels == 0) {
continue;
};
//通過(guò)選擇器取得所有key集合
Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> iterator = selectedKeys.iterator();
while (iterator.hasNext()){
SelectionKey key = iterator.next();
//判斷狀態(tài)是否有效
if (!key.isValid()) {
continue;
}
if (key.isAcceptable()) {
// 處理通道中的連接事件
ServerSocketChannel server = (ServerSocketChannel) key.channel();
SocketChannel sc = server.accept();
sc.configureBlocking(false);
System.out.println("接收到新的客戶端連接，地址：" + sc.getRemoteAddress());
// 將通道注冊(cè)到選擇器并處理通道中可讀事件
sc.register(selector, SelectionKey.OP_READ);
} else if (key.isReadable()) {
// 處理通道中的可讀事件
SocketChannel channel = (SocketChannel) key.channel();
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
while (channel.isOpen() && channel.read(byteBuffer) != -1) {
// 長(zhǎng)連接情況下,需要手動(dòng)判斷數(shù)據(jù)有沒(méi)有讀取結(jié)束 (此處做一個(gè)簡(jiǎn)單的判斷: 超過(guò)0字節(jié)就認(rèn)為請(qǐng)求結(jié)束了)
if (byteBuffer.position() > 0) {
break;
};
}
byteBuffer.flip();
//獲取緩沖中的數(shù)據(jù)
String result = new String(byteBuffer.array(), 0, byteBuffer.limit());
System.out.println("收到客戶端發(fā)送的信息，內(nèi)容：" + result);
// 將通道注冊(cè)到選擇器并處理通道中可寫(xiě)事件
channel.register(selector, SelectionKey.OP_WRITE);
} else if (key.isWritable()) {
// 處理通道中的可寫(xiě)事件
SocketChannel channel = (SocketChannel) key.channel();
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
byteBuffer.put("server send".getBytes());
byteBuffer.flip();
channel.write(byteBuffer);
// 將通道注冊(cè)到選擇器并處理通道中可讀事件
channel.register(selector, SelectionKey.OP_READ);
//寫(xiě)完之后關(guān)閉通道
channel.close();
}
//當(dāng)前事件已經(jīng)處理完畢，可以丟棄
iterator.remove();
}
}
}
}客戶端操作，樣例程序如下：
/**
* NIO 客戶端
*/
public class NioClientTest {
public static void main(String[] args) throws IOException {
// 打開(kāi)socket通道
SocketChannel sc = SocketChannel.open();
//設(shè)置為非阻塞
sc.configureBlocking(false);
//連接服務(wù)器地址和端口
sc.connect(new InetSocketAddress("127.0.0.1", 8080));
while (!sc.finishConnect()) {
// 沒(méi)連接上,則一直等待
System.out.println("客戶端正在連接中，請(qǐng)耐心等待");
}
// 發(fā)送內(nèi)容
ByteBuffer writeBuffer = ByteBuffer.allocate(1024);
writeBuffer.put("Hello，我是客戶端".getBytes());
writeBuffer.flip();
sc.write(writeBuffer);
// 讀取響應(yīng)
ByteBuffer readBuffer = ByteBuffer.allocate(1024);
while (sc.isOpen() && sc.read(readBuffer) != -1) {
// 長(zhǎng)連接情況下,需要手動(dòng)判斷數(shù)據(jù)有沒(méi)有讀取結(jié)束 (此處做一個(gè)簡(jiǎn)單的判斷: 超過(guò)0字節(jié)就認(rèn)為請(qǐng)求結(jié)束了)
if (readBuffer.position() > 0) {
break;
};
}
readBuffer.flip();
String result = new String(readBuffer.array(), 0, readBuffer.limit());
System.out.println("客戶端收到服務(wù)端：" + sc.socket().getRemoteSocketAddress() + "，返回的信息：" + result);
// 關(guān)閉通道
sc.close();
}
}最后，依次啟動(dòng)服務(wù)端、客戶端，看看控制臺(tái)輸出情況如何。
服務(wù)端控制臺(tái)結(jié)果如下：
接收到新的客戶端連接，地址：/127.0.0.1:57644
收到客戶端發(fā)送的信息，內(nèi)容：Hello，我是客戶端客戶端控制臺(tái)結(jié)果如下：
客戶端收到服務(wù)端：/127.0.0.1:8080，返回的信息：server send從編程上可以看到，NIO 的操作比傳統(tǒng)的 IO 操作要復(fù)雜的多！
Selector 被稱為選擇器 ，當(dāng)然你也可以翻譯為多路復(fù)用器 。它是Java NIO 核心組件中的一個(gè)，用于檢查一個(gè)或多個(gè) Channel（通道）的狀態(tài)是否處于連接就緒、接受就緒、可讀就緒、可寫(xiě)就緒。
如此可以實(shí)現(xiàn)單線程管理多個(gè) channels 的目的，也就是可以管理多個(gè)網(wǎng)絡(luò)連接。
使用 Selector 的好處在于 ：相比傳統(tǒng)方式使用多個(gè)線程來(lái)管理 IO，Selector 使用了更少的線程就可以處理通道了，并且實(shí)現(xiàn)網(wǎng)絡(luò)高效傳輸！
雖然 Java 中的 nio 傳輸比較快，為什么大家都不愿意用 JDK 原生 NIO 進(jìn)行開(kāi)發(fā)呢？
從上面的代碼中大家都可以看出來(lái)，除了編程復(fù)雜之外，還有幾個(gè)讓人詬病的問(wèn)題：
- JDK 的 NIO 底層由 epoll 實(shí)現(xiàn)，該實(shí)現(xiàn)飽受詬病的空輪詢 bug 會(huì)導(dǎo)致 cpu 飆升 100%！
- 項(xiàng)目龐大之后，自行實(shí)現(xiàn)的 NIO 很容易出現(xiàn)各類 bug，維護(hù)成本較高！
但是，Google 的 Netty 框架的出現(xiàn)，很大程度上改善了 JDK 原生 NIO 所存在的一些讓人難以忍受的問(wèn)題，關(guān)于 Netty 框架應(yīng)用，會(huì)在后期的文章里進(jìn)行介紹。
五、AIO
最后就是 AIO 了，全稱 Asynchronous I/O，可以理解為異步 IO，也被稱為 NIO 2，在 Java 7 中引入，它是異步非阻塞的 IO 模型。
異步 IO 是基于事件回調(diào)機(jī)制實(shí)現(xiàn)的，也就是應(yīng)用操作之后會(huì)直接返回，不會(huì)堵塞在那里，當(dāng)后臺(tái)處理完成，操作系統(tǒng)會(huì)通知相應(yīng)的線程進(jìn)行后續(xù)的操作。
具體的實(shí)例如下！
服務(wù)端操作，樣例程序如下：
/**
* aio 服務(wù)端
*/
public class AioServer {
public AsynchronousServerSocketChannel serverChannel;
/**
* 監(jiān)聽(tīng)客戶端請(qǐng)求
* @throws Exception
*/
public void listen() throws Exception {
//打開(kāi)一個(gè)服務(wù)端通道
serverChannel = AsynchronousServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress(8080));//監(jiān)聽(tīng)8080端口
//服務(wù)監(jiān)聽(tīng)
serverChannel.accept(this, new CompletionHandler<AsynchronousSocketChannel,AioServer>(){
@Override
public void completed(AsynchronousSocketChannel client, AioServer attachment) {
try {
if (client.isOpen()) {
System.out.println("接收到新的客戶端連接，地址：" + client.getRemoteAddress());
final ByteBuffer buffer = ByteBuffer.allocate(1024);
//讀取客戶端發(fā)送的信息
client.read(buffer, client, new CompletionHandler<Integer, AsynchronousSocketChannel>(){
@Override
public void completed(Integer result, AsynchronousSocketChannel attachment) {
try {
//讀取請(qǐng)求，處理客戶端發(fā)送的數(shù)據(jù)
buffer.flip();
String content = new String(buffer.array(), 0, buffer.limit());
System.out.println("服務(wù)端收到客戶端發(fā)送的信息：" + content);
//向客戶端發(fā)送數(shù)據(jù)
ByteBuffer writeBuffer = ByteBuffer.allocate(1024);
writeBuffer.put("server send".getBytes());
writeBuffer.flip();
attachment.write(writeBuffer).get();
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void failed(Throwable exc, AsynchronousSocketChannel attachment) {
try {
exc.printStackTrace();
attachment.close();
} catch (IOException e) {
e.printStackTrace();
}
}
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//當(dāng)有新客戶端接入的時(shí)候，直接調(diào)用accept方法，遞歸執(zhí)行下去，保證多個(gè)客戶端都可以阻塞
attachment.serverChannel.accept(attachment, this);
}
}
@Override
public void failed(Throwable exc, AioServer attachment) {
exc.printStackTrace();
}
});
}
public static void main(String[] args) throws Exception {
//啟動(dòng)服務(wù)器，并監(jiān)聽(tīng)客戶端
new AioServer().listen();
//因?yàn)槭钱惒絀O執(zhí)行，讓主線程睡眠但不關(guān)閉
Thread.sleep(Integer.MAX_VALUE);
}
}客戶端操作，樣例程序如下：
/**
* aio 客戶端
*/
public class AioClient {
public static void main(String[] args) throws IOException, InterruptedException {
//打開(kāi)一個(gè)客戶端通道
AsynchronousSocketChannel channel = AsynchronousSocketChannel.open();
//與服務(wù)器建立連接
channel.connect(new InetSocketAddress("127.0.0.1", 8080));
//睡眠1s，等待與服務(wù)器建立連接
Thread.sleep(1000);
try {
//向服務(wù)器發(fā)送數(shù)據(jù)
channel.write(ByteBuffer.wrap("Hello，我是客戶端".getBytes())).get();
} catch (Exception e) {
e.printStackTrace();
}
try {
//從服務(wù)器讀取數(shù)據(jù)
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
channel.read(byteBuffer).get();//將通道中的數(shù)據(jù)寫(xiě)入緩沖buffer
byteBuffer.flip();
String result = new String(byteBuffer.array(), 0, byteBuffer.limit());
System.out.println("客戶端收到服務(wù)器返回的內(nèi)容：" + result);//輸出返回結(jié)果
} catch (Exception e) {
e.printStackTrace();
}
}
}同樣的，依次啟動(dòng)服務(wù)端程序，再啟動(dòng)客戶端程序，看看運(yùn)行結(jié)果！
服務(wù)端控制臺(tái)結(jié)果如下：
接收到新的客戶端連接，地址：/127.0.0.1:56606
服務(wù)端收到客戶端發(fā)送的信息：Hello，我是客戶端客戶端控制臺(tái)結(jié)果如下：
客戶端收到服務(wù)器返回的內(nèi)容：server send這種組合方式用起來(lái)十分復(fù)雜，只有在一些非常復(fù)雜的分布式情況下使用，像集群之間的消息同步機(jī)制一般用這種 I/O 組合方式。如 Cassandra 的 Gossip 通信機(jī)制就是采用異步非阻塞的方式，可以實(shí)現(xiàn)非常高的網(wǎng)絡(luò)傳輸性能。
Netty 之前也嘗試使用過(guò) AIO，不過(guò)又放棄了！
六、小結(jié)
本文主要圍繞 BIO、NIO、AIO 等模型，結(jié)合一些樣例代碼，做了一次簡(jiǎn)單的內(nèi)容知識(shí)總結(jié)，希望對(duì)大家有所幫助。
內(nèi)容難免有所遺漏，歡迎留言指出！
七、參考
1、JDK1.7&JDK1.8 源碼
2、IBM - 許令波 -深入分析 Java I/O 的工作機(jī)制
3、Github - JavaGuide - IO總結(jié)
4、博客園 - 五月的倉(cāng)頡 - IO和File
