關於BIO, NIO, AIO的一篇很好的文章,不光是概念上的總結還有很詳細的源碼示例
轉自:http://blog.csdn.net/anxpp/article/details/51512200
本文會從傳統的BIO到NIO再到AIO自淺至深介紹,並附上完整的代碼講解。
下面代碼中會使用這樣一個例子:客戶端發送一段算式的字符串到服務器,服務器計算後返回結果到客戶端。
代碼的所有說明,都直接作爲註釋,嵌入到代碼中,看代碼時就能更容易理解,代碼中會用到一個計算結果的工具類,見文章代碼部分。
相關的基礎知識文章推薦:
Linux 網絡 I/O 模型簡介(圖文)
Java 併發(多線程)
1、BIO編程
1.1、傳統的BIO編程
網絡編程的基本模型是C/S模型,即兩個進程間的通信。
服務端提供IP和監聽端口,客戶端通過連接操作想服務端監聽的地址發起連接請求,通過三次握手連接,如果連接成功建立,雙方就可以通過套接字進行通信。
傳統的同步阻塞模型開發中,ServerSocket負責綁定IP地址,啓動監聽端口;Socket負責發起連接操作。連接成功後,雙方通過輸入和輸出流進行同步阻塞式通信。
簡單的描述一下BIO的服務端通信模型:採用BIO通信模型的服務端,通常由一個獨立的Acceptor線程負責監聽客戶端的連接,它接收到客戶端連接請求之後爲每個客戶端創建一個新的線程進行鏈路處理沒處理完成後,通過輸出流返回應答給客戶端,線程銷燬。即典型的一請求一應答通宵模型。
傳統BIO通信模型圖:
該模型最大的問題就是缺乏彈性伸縮能力,當客戶端併發訪問量增加後,服務端的線程個數和客戶端併發訪問數呈1:1的正比關係,Java中的線程也是比較寶貴的系統資源,線程數量快速膨脹後,系統的性能將急劇下降,隨着訪問量的繼續增大,系統最終就死-掉-了。
同步阻塞式I/O創建的Server源碼:
-
package com.anxpp.io.calculator.bio;
-
import java.io.IOException;
-
import java.net.ServerSocket;
-
import java.net.Socket;
-
-
-
-
-
-
public final class ServerNormal {
-
-
private static int DEFAULT_PORT = 12345;
-
-
private static ServerSocket server;
-
-
public static void start() throws IOException{
-
-
start(DEFAULT_PORT);
-
}
-
-
public synchronized static void start(int port) throws IOException{
-
if(server != null) return;
-
try{
-
-
-
server = new ServerSocket(port);
-
System.out.println("服務器已啓動,端口號:" + port);
-
Socket socket;
-
-
-
while(true){
-
socket = server.accept();
-
-
-
new Thread(new ServerHandler(socket)).start();
-
}
-
}finally{
-
-
if(server != null){
-
System.out.println("服務器已關閉。");
-
server.close();
-
server = null;
-
}
-
}
-
}
-
}
客戶端消息處理線程ServerHandler源碼:
-
package com.anxpp.io.calculator.bio;
-
import java.io.BufferedReader;
-
import java.io.IOException;
-
import java.io.InputStreamReader;
-
import java.io.PrintWriter;
-
import java.net.Socket;
-
-
import com.anxpp.io.utils.Calculator;
-
-
-
-
-
-
public class ServerHandler implements Runnable{
-
private Socket socket;
-
public ServerHandler(Socket socket) {
-
this.socket = socket;
-
}
-
@Override
-
public void run() {
-
BufferedReader in = null;
-
PrintWriter out = null;
-
try{
-
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
-
out = new PrintWriter(socket.getOutputStream(),true);
-
String expression;
-
String result;
-
while(true){
-
-
-
-
if((expression = in.readLine())==null) break;
-
System.out.println("服務器收到消息:" + expression);
-
try{
-
result = Calculator.cal(expression).toString();
-
}catch(Exception e){
-
result = "計算錯誤:" + e.getMessage();
-
}
-
out.println(result);
-
}
-
}catch(Exception e){
-
e.printStackTrace();
-
}finally{
-
-
if(in != null){
-
try {
-
in.close();
-
} catch (IOException e) {
-
e.printStackTrace();
-
}
-
in = null;
-
}
-
if(out != null){
-
out.close();
-
out = null;
-
}
-
if(socket != null){
-
try {
-
socket.close();
-
} catch (IOException e) {
-
e.printStackTrace();
-
}
-
socket = null;
-
}
-
}
-
}
-
}
同步阻塞式I/O創建的Client源碼:
-
package com.anxpp.io.calculator.bio;
-
import java.io.BufferedReader;
-
import java.io.IOException;
-
import java.io.InputStreamReader;
-
import java.io.PrintWriter;
-
import java.net.Socket;
-
-
-
-
-
-
public class Client {
-
-
private static int DEFAULT_SERVER_PORT = 12345;
-
private static String DEFAULT_SERVER_IP = "127.0.0.1";
-
public static void send(String expression){
-
send(DEFAULT_SERVER_PORT,expression);
-
}
-
public static void send(int port,String expression){
-
System.out.println("算術表達式爲:" + expression);
-
Socket socket = null;
-
BufferedReader in = null;
-
PrintWriter out = null;
-
try{
-
socket = new Socket(DEFAULT_SERVER_IP,port);
-
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
-
out = new PrintWriter(socket.getOutputStream(),true);
-
out.println(expression);
-
System.out.println("___結果爲:" + in.readLine());
-
}catch(Exception e){
-
e.printStackTrace();
-
}finally{
-
-
if(in != null){
-
try {
-
in.close();
-
} catch (IOException e) {
-
e.printStackTrace();
-
}
-
in = null;
-
}
-
if(out != null){
-
out.close();
-
out = null;
-
}
-
if(socket != null){
-
try {
-
socket.close();
-
} catch (IOException e) {
-
e.printStackTrace();
-
}
-
socket = null;
-
}
-
}
-
}
-
}
測試代碼,爲了方便在控制檯看輸出結果,放到同一個程序(jvm)中運行:
-
package com.anxpp.io.calculator.bio;
-
import java.io.IOException;
-
import java.util.Random;
-
-
-
-
-
-
public class Test {
-
-
public static void main(String[] args) throws InterruptedException {
-
-
new Thread(new Runnable() {
-
@Override
-
public void run() {
-
try {
-
ServerBetter.start();
-
} catch (IOException e) {
-
e.printStackTrace();
-
}
-
}
-
}).start();
-
-
Thread.sleep(100);
-
-
char operators[] = {'+','-','*','/'};
-
Random random = new Random(System.currentTimeMillis());
-
new Thread(new Runnable() {
-
@SuppressWarnings("static-access")
-
@Override
-
public void run() {
-
while(true){
-
-
String expression = random.nextInt(10)+""+operators[random.nextInt(4)]+(random.nextInt(10)+1);
-
Client.send(expression);
-
try {
-
Thread.currentThread().sleep(random.nextInt(1000));
-
} catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
}
-
}
-
}).start();
-
}
-
}
其中一次的運行結果:
- 服務器已啓動,端口號:12345
- 算術表達式爲:4-2
- 服務器收到消息:4-2
- ___結果爲:2
- 算術表達式爲:5-10
- 服務器收到消息:5-10
- ___結果爲:-5
- 算術表達式爲:0-9
- 服務器收到消息:0-9
- ___結果爲:-9
- 算術表達式爲:0+6
- 服務器收到消息:0+6
- ___結果爲:6
- 算術表達式爲:1/6
- 服務器收到消息:1/6
- ___結果爲:0.16666666666666666
- ...
從以上代碼,很容易看出,BIO主要的問題在於每當有一個新的客戶端請求接入時,服務端必須創建一個新的線程來處理這條鏈路,在需要滿足高性能、高併發的場景是沒法應用的(大量創建新的線程會嚴重影響服務器性能,甚至罷工)。
1.2、僞異步I/O編程
爲了改進這種一連接一線程的模型,我們可以使用線程池來管理這些線程(需要了解更多請參考前面提供的文章),實現1個或多個線程處理N個客戶端的模型(但是底層還是使用的同步阻塞I/O),通常被稱爲“僞異步I/O模型“。
僞異步I/O模型圖:
實現很簡單,我們只需要將新建線程的地方,交給線程池管理即可,只需要改動剛剛的Server代碼即可:
-
package com.anxpp.io.calculator.bio;
-
import java.io.IOException;
-
import java.net.ServerSocket;
-
import java.net.Socket;
-
import java.util.concurrent.ExecutorService;
-
import java.util.concurrent.Executors;
-
-
-
-
-
-
public final class ServerBetter {
-
-
private static int DEFAULT_PORT = 12345;
-
-
private static ServerSocket server;
-
-
private static ExecutorService executorService = Executors.newFixedThreadPool(60);
-
-
public static void start() throws IOException{
-
-
start(DEFAULT_PORT);
-
}
-
-
public synchronized static void start(int port) throws IOException{
-
if(server != null) return;
-
try{
-
-
-
server = new ServerSocket(port);
-
System.out.println("服務器已啓動,端口號:" + port);
-
Socket socket;
-
-
-
while(true){
-
socket = server.accept();
-
-
-
executorService.execute(new ServerHandler(socket));
-
}
-
}finally{
-
-
if(server != null){
-
System.out.println("服務器已關閉。");
-
server.close();
-
server = null;
-
}
-
}
-
}
-
}
測試運行結果是一樣的。
我們知道,如果使用CachedThreadPool線程池(不限制線程數量,如果不清楚請參考文首提供的文章),其實除了能自動幫我們管理線程(複用),看起來也就像是1:1的客戶端:線程數模型,而使用FixedThreadPool我們就有效的控制了線程的最大數量,保證了系統有限的資源的控制,實現了N:M的僞異步I/O模型。
但是,正因爲限制了線程數量,如果發生大量併發請求,超過最大數量的線程就只能等待,直到線程池中的有空閒的線程可以被複用。而對Socket的輸入流就行讀取時,會一直阻塞,直到發生:
- 有數據可讀
- 可用數據以及讀取完畢
- 發生空指針或I/O異常
所以在讀取數據較慢時(比如數據量大、網絡傳輸慢等),大量併發的情況下,其他接入的消息,只能一直等待,這就是最大的弊端。
而後面即將介紹的NIO,就能解決這個難題。
2、NIO 編程
JDK 1.4中的java.nio.*包中引入新的Java I/O庫,其目的是提高速度。實際上,“舊”的I/O包已經使用NIO重新實現過,即使我們不顯式的使用NIO編程,也能從中受益。速度的提高在文件I/O和網絡I/O中都可能會發生,但本文只討論後者。
2.1、簡介
NIO我們一般認爲是New I/O(也是官方的叫法),因爲它是相對於老的I/O類庫新增的(其實在JDK 1.4中就已經被引入了,但這個名詞還會繼續用很久,即使它們在現在看來已經是“舊”的了,所以也提示我們在命名時,需要好好考慮),做了很大的改變。但民間跟多人稱之爲Non-block I/O,即非阻塞I/O,因爲這樣叫,更能體現它的特點。而下文中的NIO,不是指整個新的I/O庫,而是非阻塞I/O。
NIO提供了與傳統BIO模型中的Socket和ServerSocket相對應的SocketChannel和ServerSocketChannel兩種不同的套接字通道實現。
新增的着兩種通道都支持阻塞和非阻塞兩種模式。
阻塞模式使用就像傳統中的支持一樣,比較簡單,但是性能和可靠性都不好;非阻塞模式正好與之相反。
對於低負載、低併發的應用程序,可以使用同步阻塞I/O來提升開發速率和更好的維護性;對於高負載、高併發的(網絡)應用,應使用NIO的非阻塞模式來開發。
下面會先對基礎知識進行介紹。
2.2、緩衝區 Buffer
Buffer是一個對象,包含一些要寫入或者讀出的數據。
在NIO庫中,所有數據都是用緩衝區處理的。在讀取數據時,它是直接讀到緩衝區中的;在寫入數據時,也是寫入到緩衝區中。任何時候訪問NIO中的數據,都是通過緩衝區進行操作。
緩衝區實際上是一個數組,並提供了對數據結構化訪問以及維護讀寫位置等信息。
具體的緩存區有這些:ByteBuffe、CharBuffer、 ShortBuffer、IntBuffer、LongBuffer、FloatBuffer、DoubleBuffer。他們實現了相同的接口:Buffer。
2.3、通道 Channel
我們對數據的讀取和寫入要通過Channel,它就像水管一樣,是一個通道。通道不同於流的地方就是通道是雙向的,可以用於讀、寫和同時讀寫操作。
底層的操作系統的通道一般都是全雙工的,所以全雙工的Channel比流能更好的映射底層操作系統的API。
Channel主要分兩大類:
- SelectableChannel:用戶網絡讀寫
- FileChannel:用於文件操作
後面代碼會涉及的ServerSocketChannel和SocketChannel都是SelectableChannel的子類。
2.4、多路複用器 Selector
Selector是Java NIO 編程的基礎。
Selector提供選擇已經就緒的任務的能力:Selector會不斷輪詢註冊在其上的Channel,如果某個Channel上面發生讀或者寫事件,這個Channel就處於就緒狀態,會被Selector輪詢出來,然後通過SelectionKey可以獲取就緒Channel的集合,進行後續的I/O操作。
一個Selector可以同時輪詢多個Channel,因爲JDK使用了epoll()代替傳統的select實現,所以沒有最大連接句柄1024/2048的限制。所以,只需要一個線程負責Selector的輪詢,就可以接入成千上萬的客戶端。
2.5、NIO服務端
代碼比傳統的Socket編程看起來要複雜不少。
直接貼代碼吧,以註釋的形式給出代碼說明。
NIO創建的Server源碼:
-
package com.anxpp.io.calculator.nio;
-
public class Server {
-
private static int DEFAULT_PORT = 12345;
-
private static ServerHandle serverHandle;
-
public static void start(){
-
start(DEFAULT_PORT);
-
}
-
public static synchronized void start(int port){
-
if(serverHandle!=null)
-
serverHandle.stop();
-
serverHandle = new ServerHandle(port);
-
new Thread(serverHandle,"Server").start();
-
}
-
public static void main(String[] args){
-
start();
-
}
-
}
ServerHandle:
可以看到,創建NIO服務端的主要步驟如下:
- 打開ServerSocketChannel,監聽客戶端連接
- 綁定監聽端口,設置連接爲非阻塞模式
- 創建Reactor線程,創建多路複用器並啓動線程
- 將ServerSocketChannel註冊到Reactor線程中的Selector上,監聽ACCEPT事件
- Selector輪詢準備就緒的key
- Selector監聽到新的客戶端接入,處理新的接入請求,完成TCP三次握手,簡歷物理鏈路
- 設置客戶端鏈路爲非阻塞模式
- 將新接入的客戶端連接註冊到Reactor線程的Selector上,監聽讀操作,讀取客戶端發送的網絡消息
- 異步讀取客戶端消息到緩衝區
- 對Buffer編解碼,處理半包消息,將解碼成功的消息封裝成Task
- 將應答消息編碼爲Buffer,調用SocketChannel的write將消息異步發送給客戶端
因爲應答消息的發送,SocketChannel也是異步非阻塞的,所以不能保證一次能吧需要發送的數據發送完,此時就會出現寫半包的問題。我們需要註冊寫操作,不斷輪詢Selector將沒有發送完的消息發送完畢,然後通過Buffer的hasRemain()方法判斷消息是否發送完成。
2.6、NIO客戶端
還是直接上代碼吧,過程也不需要太多解釋了,跟服務端代碼有點類似。
Client:
-
package com.anxpp.io.calculator.nio;
-
public class Client {
-
private static String DEFAULT_HOST = "127.0.0.1";
-
private static int DEFAULT_PORT = 12345;
-
private static ClientHandle clientHandle;
-
public static void start(){
-
start(DEFAULT_HOST,DEFAULT_PORT);
-
}
-
public static synchronized void start(String ip,int port){
-
if(clientHandle!=null)
-
clientHandle.stop();
-
clientHandle = new ClientHandle(ip,port);
-
new Thread(clientHandle,"Server").start();
-
}
-
-
public static boolean sendMsg(String msg) throws Exception{
-
if(msg.equals("q")) return false;
-
clientHandle.sendMsg(msg);
-
return true;
-
}
-
public static void main(String[] args){
-
start();
-
}
-
}
ClientHandle:
2.7、演示結果
首先運行服務器,順便也運行一個客戶端:
-
package com.anxpp.io.calculator.nio;
-
import java.util.Scanner;
-
-
-
-
-
-
public class Test {
-
-
@SuppressWarnings("resource")
-
public static void main(String[] args) throws Exception{
-
-
Server.start();
-
-
Thread.sleep(100);
-
-
Client.start();
-
while(Client.sendMsg(new Scanner(System.in).nextLine()));
-
}
-
}
我們也可以單獨運行客戶端,效果都是一樣的。
一次測試的結果:
- 服務器已啓動,端口號:12345
- 1+2+3+4+5+6
- 服務器收到消息:1+2+3+4+5+6
- 客戶端收到消息:21
- 1*2/3-4+5*6/7-8
- 服務器收到消息:1*2/3-4+5*6/7-8
- 客戶端收到消息:-7.0476190476190474
運行多個客戶端,都是沒有問題的。
3、AIO編程
NIO 2.0引入了新的異步通道的概念,並提供了異步文件通道和異步套接字通道的實現。
異步的套接字通道時真正的異步非阻塞I/O,對應於UNIX網絡編程中的事件驅動I/O(AIO)。他不需要過多的Selector對註冊的通道進行輪詢即可實現異步讀寫,從而簡化了NIO的編程模型。
直接上代碼吧。
3.1、Server端代碼
Server:
-
package com.anxpp.io.calculator.aio.server;
-
-
-
-
-
-
public class Server {
-
private static int DEFAULT_PORT = 12345;
-
private static AsyncServerHandler serverHandle;
-
public volatile static long clientCount = 0;
-
public static void start(){
-
start(DEFAULT_PORT);
-
}
-
public static synchronized void start(int port){
-
if(serverHandle!=null)
-
return;
-
serverHandle = new AsyncServerHandler(port);
-
new Thread(serverHandle,"Server").start();
-
}
-
public static void main(String[] args){
-
Server.start();
-
}
-
}
AsyncServerHandler:
-
package com.anxpp.io.calculator.aio.server;
-
import java.io.IOException;
-
import java.net.InetSocketAddress;
-
import java.nio.channels.AsynchronousServerSocketChannel;
-
import java.util.concurrent.CountDownLatch;
-
public class AsyncServerHandler implements Runnable {
-
public CountDownLatch latch;
-
public AsynchronousServerSocketChannel channel;
-
public AsyncServerHandler(int port) {
-
try {
-
-
channel = AsynchronousServerSocketChannel.open();
-
-
channel.bind(new InetSocketAddress(port));
-
System.out.println("服務器已啓動,端口號:" + port);
-
} catch (IOException e) {
-
e.printStackTrace();
-
}
-
}
-
@Override
-
public void run() {
-
-
-
-
-
-
latch = new CountDownLatch(1);
-
-
channel.accept(this,new AcceptHandler());
-
try {
-
latch.await();
-
} catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
}
-
}
AcceptHandler:
-
package com.anxpp.io.calculator.aio.server;
-
import java.nio.ByteBuffer;
-
import java.nio.channels.AsynchronousSocketChannel;
-
import java.nio.channels.CompletionHandler;
-
-
public class AcceptHandler implements CompletionHandler<AsynchronousSocketChannel, AsyncServerHandler> {
-
@Override
-
public void completed(AsynchronousSocketChannel channel,AsyncServerHandler serverHandler) {
-
-
Server.clientCount++;
-
System.out.println("連接的客戶端數:" + Server.clientCount);
-
serverHandler.channel.accept(serverHandler, this);
-
-
ByteBuffer buffer = ByteBuffer.allocate(1024);
-
-
channel.read(buffer, buffer, new ReadHandler(channel));
-
}
-
@Override
-
public void failed(Throwable exc, AsyncServerHandler serverHandler) {
-
exc.printStackTrace();
-
serverHandler.latch.countDown();
-
}
-
}
ReadHandler:
-
package com.anxpp.io.calculator.aio.server;
-
import java.io.IOException;
-
import java.io.UnsupportedEncodingException;
-
import java.nio.ByteBuffer;
-
import java.nio.channels.AsynchronousSocketChannel;
-
import java.nio.channels.CompletionHandler;
-
import com.anxpp.io.utils.Calculator;
-
public class ReadHandler implements CompletionHandler<Integer, ByteBuffer> {
-
-
private AsynchronousSocketChannel channel;
-
public ReadHandler(AsynchronousSocketChannel channel) {
-
this.channel = channel;
-
}
-
-
@Override
-
public void completed(Integer result, ByteBuffer attachment) {
-
-
attachment.flip();
-
-
byte[] message = new byte[attachment.remaining()];
-
attachment.get(message);
-
try {
-
String expression = new String(message, "UTF-8");
-
System.out.println("服務器收到消息: " + expression);
-
String calrResult = null;
-
try{
-
calrResult = Calculator.cal(expression).toString();
-
}catch(Exception e){
-
calrResult = "計算錯誤:" + e.getMessage();
-
}
-
-
doWrite(calrResult);
-
} catch (UnsupportedEncodingException e) {
-
e.printStackTrace();
-
}
-
}
-
-
private void doWrite(String result) {
-
byte[] bytes = result.getBytes();
-
ByteBuffer writeBuffer = ByteBuffer.allocate(bytes.length);
-
writeBuffer.put(bytes);
-
writeBuffer.flip();
-
-
channel.write(writeBuffer, writeBuffer,new CompletionHandler<Integer, ByteBuffer>() {
-
@Override
-
public void completed(Integer result, ByteBuffer buffer) {
-
-
if (buffer.hasRemaining())
-
channel.write(buffer, buffer, this);
-
else{
-
-
ByteBuffer readBuffer = ByteBuffer.allocate(1024);
-
-
channel.read(readBuffer, readBuffer, new ReadHandler(channel));
-
}
-
}
-
@Override
-
public void failed(Throwable exc, ByteBuffer attachment) {
-
try {
-
channel.close();
-
} catch (IOException e) {
-
}
-
}
-
});
-
}
-
@Override
-
public void failed(Throwable exc, ByteBuffer attachment) {
-
try {
-
this.channel.close();
-
} catch (IOException e) {
-
e.printStackTrace();
-
}
-
}
-
}
OK,這樣就已經完成了,其實說起來也簡單,雖然代碼感覺很多,但是API比NIO的使用起來真的簡單多了,主要就是監聽、讀、寫等各種CompletionHandler。此處本應有一個WriteHandler的,確實,我們在ReadHandler中,以一個匿名內部類實現了它。
下面看客戶端代碼。
3.2、Client端代碼
Client:
-
package com.anxpp.io.calculator.aio.client;
-
import java.util.Scanner;
-
public class Client {
-
private static String DEFAULT_HOST = "127.0.0.1";
-
private static int DEFAULT_PORT = 12345;
-
private static AsyncClientHandler clientHandle;
-
public static void start(){
-
start(DEFAULT_HOST,DEFAULT_PORT);
-
}
-
public static synchronized void start(String ip,int port){
-
if(clientHandle!=null)
-
return;
-
clientHandle = new AsyncClientHandler(ip,port);
-
new Thread(clientHandle,"Client").start();
-
}
-
-
public static boolean sendMsg(String msg) throws Exception{
-
if(msg.equals("q")) return false;
-
clientHandle.sendMsg(msg);
-
return true;
-
}
-
@SuppressWarnings("resource")
-
public static void main(String[] args) throws Exception{
-
Client.start();
-
System.out.println("請輸入請求消息:");
-
Scanner scanner = new Scanner(System.in);
-
while(Client.sendMsg(scanner.nextLine()));
-
}
-
}
AsyncClientHandler:
-
package com.anxpp.io.calculator.aio.client;
-
import java.io.IOException;
-
import java.net.InetSocketAddress;
-
import java.nio.ByteBuffer;
-
import java.nio.channels.AsynchronousSocketChannel;
-
import java.nio.channels.CompletionHandler;
-
import java.util.concurrent.CountDownLatch;
-
public class AsyncClientHandler implements CompletionHandler<Void, AsyncClientHandler>, Runnable {
-
private AsynchronousSocketChannel clientChannel;
-
private String host;
-
private int port;
-
private CountDownLatch latch;
-
public AsyncClientHandler(String host, int port) {
-
this.host = host;
-
this.port = port;
-
try {
-
-
clientChannel = AsynchronousSocketChannel.open();
-
} catch (IOException e) {
-
e.printStackTrace();
-
}
-
}
-
@Override
-
public void run() {
-
-
latch = new CountDownLatch(1);
-
-
clientChannel.connect(new InetSocketAddress(host, port), this, this);
-
try {
-
latch.await();
-
} catch (InterruptedException e1) {
-
e1.printStackTrace();
-
}
-
try {
-
clientChannel.close();
-
} catch (IOException e) {
-
e.printStackTrace();
-
}
-
}
-
-
-
@Override
-
public void completed(Void result, AsyncClientHandler attachment) {
-
System.out.println("客戶端成功連接到服務器...");
-
}
-
-
@Override
-
public void failed(Throwable exc, AsyncClientHandler attachment) {
-
System.err.println("連接服務器失敗...");
-
exc.printStackTrace();
-
try {
-
clientChannel.close();
-
latch.countDown();
-
} catch (IOException e) {
-
e.printStackTrace();
-
}
-
}
-
-
public void sendMsg(String msg){
-
byte[] req = msg.getBytes();
-
ByteBuffer writeBuffer = ByteBuffer.allocate(req.length);
-
writeBuffer.put(req);
-
writeBuffer.flip();
-
-
clientChannel.write(writeBuffer, writeBuffer,new WriteHandler(clientChannel, latch));
-
}
-
}
WriteHandler:
-
package com.anxpp.io.calculator.aio.client;
-
import java.io.IOException;
-
import java.nio.ByteBuffer;
-
import java.nio.channels.AsynchronousSocketChannel;
-
import java.nio.channels.CompletionHandler;
-
import java.util.concurrent.CountDownLatch;
-
public class WriteHandler implements CompletionHandler<Integer, ByteBuffer> {
-
private AsynchronousSocketChannel clientChannel;
-
private CountDownLatch latch;
-
public WriteHandler(AsynchronousSocketChannel clientChannel,CountDownLatch latch) {
-
this.clientChannel = clientChannel;
-
this.latch = latch;
-
}
-
@Override
-
public void completed(Integer result, ByteBuffer buffer) {
-
-
if (buffer.hasRemaining()) {
-
clientChannel.write(buffer, buffer, this);
-
}
-
else {
-
-
ByteBuffer readBuffer = ByteBuffer.allocate(1024);
-
clientChannel.read(readBuffer,readBuffer,new ReadHandler(clientChannel, latch));
-
}
-
}
-
@Override
-
public void failed(Throwable exc, ByteBuffer attachment) {
-
System.err.println("數據發送失敗...");
-
try {
-
clientChannel.close();
-
latch.countDown();
-
} catch (IOException e) {
-
}
-
}
-
}
ReadHandler:
-
package com.anxpp.io.calculator.aio.client;
-
import java.io.IOException;
-
import java.io.UnsupportedEncodingException;
-
import java.nio.ByteBuffer;
-
import java.nio.channels.AsynchronousSocketChannel;
-
import java.nio.channels.CompletionHandler;
-
import java.util.concurrent.CountDownLatch;
-
public class ReadHandler implements CompletionHandler<Integer, ByteBuffer> {
-
private AsynchronousSocketChannel clientChannel;
-
private CountDownLatch latch;
-
public ReadHandler(AsynchronousSocketChannel clientChannel,CountDownLatch latch) {
-
this.clientChannel = clientChannel;
-
this.latch = latch;
-
}
-
@Override
-
public void completed(Integer result,ByteBuffer buffer) {
-
buffer.flip();
-
byte[] bytes = new byte[buffer.remaining()];
-
buffer.get(bytes);
-
String body;
-
try {
-
body = new String(bytes,"UTF-8");
-
System.out.println("客戶端收到結果:"+ body);
-
} catch (UnsupportedEncodingException e) {
-
e.printStackTrace();
-
}
-
}
-
@Override
-
public void failed(Throwable exc,ByteBuffer attachment) {
-
System.err.println("數據讀取失敗...");
-
try {
-
clientChannel.close();
-
latch.countDown();
-
} catch (IOException e) {
-
}
-
}
-
}
這個API使用起來真的是很順手。
3.3、測試
Test:
-
package com.anxpp.io.calculator.aio;
-
import java.util.Scanner;
-
import com.anxpp.io.calculator.aio.client.Client;
-
import com.anxpp.io.calculator.aio.server.Server;
-
-
-
-
-
-
public class Test {
-
-
@SuppressWarnings("resource")
-
public static void main(String[] args) throws Exception{
-
-
Server.start();
-
-
Thread.sleep(100);
-
-
Client.start();
-
System.out.println("請輸入請求消息:");
-
Scanner scanner = new Scanner(System.in);
-
while(Client.sendMsg(scanner.nextLine()));
-
}
-
}
我們可以在控制檯輸入我們需要計算的算數字符串,服務器就會返回結果,當然,我們也可以運行大量的客戶端,都是沒有問題的,以爲此處設計爲單例客戶端,所以也就沒有演示大量客戶端併發。
讀者可以自己修改Client類,然後開闢大量線程,並使用構造方法創建很多的客戶端測試。
下面是其中一次參數的輸出:
- 服務器已啓動,端口號:12345
- 請輸入請求消息:
- 客戶端成功連接到服務器...
- 連接的客戶端數:1
- 123456+789+456
- 服務器收到消息: 123456+789+456
- 客戶端收到結果:124701
- 9526*56
- 服務器收到消息: 9526*56
- 客戶端收到結果:533456
- ...
AIO是真正的異步非阻塞的,所以,在面對超級大量的客戶端,更能得心應手。
下面就比較一下,幾種I/O編程的優缺點。
4、各種I/O的對比
先以一張表來直觀的對比一下:
具體選擇什麼樣的模型或者NIO框架,完全基於業務的實際應用場景和性能需求,如果客戶端很少,服務器負荷不重,就沒有必要選擇開發起來相對不那麼簡單的NIO做服務端;相反,就應考慮使用NIO或者相關的框架了。
5、附錄
上文中服務端使用到的用於計算的工具類:
- package com.anxpp.utils;
- import javax.script.ScriptEngine;
- import javax.script.ScriptEngineManager;
- import javax.script.ScriptException;
- public final class Calculator {
- private final static ScriptEngine jse = new ScriptEngineManager().getEngineByName("JavaScript");
- public static Object cal(String expression) throws ScriptException{
- return jse.eval(expression);
- }
- }