Java 網絡IO編程總結

Linux五種IO模型 https://blog.csdn.net/weixin_30363263/article/details/88106286

IO的方式通常分爲幾種，同步阻塞的BIO、同步非阻塞的NIO、異步非阻塞的AIO。

一、BIO編程

1.1、傳統的BIO編程
網絡編程的基本模型是C/S模型，即兩個進程間的通信。

服務端提供IP和監聽端口，客戶端通過連接操作想服務端監聽的地址發起連接請求，通過三次握手連接，如果連接成功建立，雙方就可以通過套接字進行通信。傳統的同步阻塞模型開發中，ServerSocket負責綁定IP地址，啓動監聽端口；Socket負責發起連接操作。連接成功後，雙方通過輸入和輸出流進行同步阻塞式通信。

該模型最大的問題就是缺乏彈性伸縮能力，當客戶端併發訪問量增加後，服務端的線程個數和客戶端併發訪問數呈1:1的正比關係，Java中的線程也是比較寶貴的系統資源，線程數量快速膨脹後，系統的性能將急劇下降，隨着訪問量的繼續增大，系統最終就死-掉-了。

下面代碼中會使用這樣一個例子：客戶端發送一段算式的字符串到服務器，服務器計算後返回結果到客戶端。

package com.anxpp.io.calculator.bio;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
 * BIO服務端源碼
 */
public final class ServerNormal {
    //默認的端口號
    private static int DEFAULT_PORT = 12345;
    //單例的ServerSocket
    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{
            //通過構造函數創建ServerSocket
            //如果端口合法且空閒，服務端就監聽成功
            server = new ServerSocket(port);
            System.out.println("服務器已啓動，端口號：" + port);
            //通過無線循環監聽客戶端連接
            //如果沒有客戶端接入，將阻塞在accept操作上。
            while(true){
                Socket socket = server.accept();
                //當有新的客戶端接入時，會執行下面的代碼
                //然後創建一個新的線程處理這條Socket鏈路
                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;
/**
 * 客戶端線程
 * 用於處理一個客戶端的Socket鏈路
 */
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){
                //通過BufferedReader讀取一行
                //如果已經讀到輸入流尾部，返回null,退出循環
                //如果得到非空值，就嘗試計算結果並返回
                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;
            }
        }
    }
}

計算工具類：

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{
		//eval() 函數可計算某個字符串，並執行其中的的 JavaScript 代碼。
		return jse.eval(expression);
	}
	
}

同步阻塞式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;
/**
 * 阻塞式I/O創建的客戶端
 */
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
算術表達式爲：9/6
服務器收到消息：9/6
___結果爲：1.5
算術表達式爲：9*6
服務器收到消息：9*6
___結果爲：54
算術表達式爲：1-4
服務器收到消息：1-4
___結果爲：-3

從以上代碼，很容易看出，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;
/**
 * BIO服務端源碼__僞異步I/O
 */
public final class ServerBetter {
	//默認的端口號
	private static int DEFAULT_PORT = 12345;
	//單例的ServerSocket
	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{
			//通過構造函數創建ServerSocket
			//如果端口合法且空閒，服務端就監聽成功
			server = new ServerSocket(port);
			System.out.println("服務器已啓動，端口號：" + port);
			//通過無線循環監聽客戶端連接
			//如果沒有客戶端接入，將阻塞在accept操作上。
			while(true){
				Socket socket = server.accept();
				//當有新的客戶端接入時，會執行下面的代碼
				//然後創建一個新的線程處理這條Socket鏈路
				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，就能解決這個難題。

二、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的非阻塞模式來開發。

下面會先對基礎知識進行介紹。

NIO本身是基於事件驅動思想來完成的，其主要想解決的是BIO的大併發問題：在使用同步I/O的網絡應用中，如果要同時處理多個客戶端請求，或是在客戶端要同時和多個服務器進行通訊，就必須使用多線程來處理。也就是說，將每一個客戶端請求分配給一個線程來單獨處理。這樣做雖然可以達到我們的要求，但同時又會帶來另外一個問題。由於每創建一個線程，就要爲這個線程分配一定的內存空間（也叫工作存儲器），而且操作系統本身也對線程的總數有一定的限制。如果客戶端的請求過多，服務端程序可能會因爲不堪重負而拒絕客戶端的請求，甚至服務器可能會因此而癱瘓。

NIO基於Reactor，當socket有流可讀或可寫入socket時，操作系統會相應的通知引用程序進行處理，應用再將流讀取到緩衝區或寫入操作系統。也就是說，這個時候，已經不是一個連接就要對應一個處理線程了，而是有效的請求，對應一個線程，當連接沒有數據時，是沒有工作線程來處理的。

BIO與NIO一個比較重要的不同，是我們使用BIO的時候往往會引入多線程，每個連接一個單獨的線程；而NIO則是使用單線程或者只使用少量的多線程，每個連接共用一個線程。

NIO的最重要的地方是當一個連接創建後，不需要對應一個線程，這個連接會被註冊到多路複用器上面，所以所有的連接只需要一個線程就可以搞定，當這個線程中的多路複用器進行輪詢的時候，發現連接上有請求的話，纔開啓一個線程進行處理，也就是一個請求一個線程模式。

在NIO的處理方式中，當一個請求來的話，開啓線程進行處理，可能會等待後端應用的資源(JDBC連接等)，其實這個線程就被阻塞了，當並發上來的話，還是會有BIO一樣的問題。

　　HTTP/1.1出現後，有了Http長連接，這樣除了超時和指明特定關閉的http header外，這個鏈接是一直打開的狀態的，這樣在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：


package com.anxpp.io.calculator.nio;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;
 
import com.anxpp.io.utils.Calculator;
/**
 * NIO服務端
 */
public class ServerHandle implements Runnable{
	private Selector selector;
	private ServerSocketChannel serverChannel;
	private volatile boolean started;
	/**
	 * 構造方法
	 * @param port 指定要監聽的端口號
	 */
	public ServerHandle(int port) {
		try{
			//創建選擇器
			selector = Selector.open();
			//打開監聽通道
			serverChannel = ServerSocketChannel.open();
			//如果爲 true，則此通道將被置於阻塞模式；如果爲 false，則此通道將被置於非阻塞模式
			serverChannel.configureBlocking(false);//開啓非阻塞模式
			//綁定端口 backlog設爲1024
			serverChannel.socket().bind(new InetSocketAddress(port),1024);
			//監聽客戶端連接請求
			serverChannel.register(selector, SelectionKey.OP_ACCEPT);
			//標記服務器已開啓
			started = true;
			System.out.println("服務器已啓動，端口號：" + port);
		}catch(IOException e){
			e.printStackTrace();
			System.exit(1);
		}
	}
	public void stop(){
		started = false;
	}
	@Override
	public void run() {
		//循環遍歷selector
		while(started){
			try{
				//無論是否有讀寫事件發生，selector每隔1s被喚醒一次
				selector.select(1000);
				//阻塞,只有當至少一個註冊的事件發生的時候纔會繼續.
//				selector.select();
				Set<SelectionKey> keys = selector.selectedKeys();
				Iterator<SelectionKey> it = keys.iterator();
				SelectionKey key = null;
				while(it.hasNext()){
					key = it.next();
					it.remove();
					try{
						handleInput(key);
					}catch(Exception e){
						if(key != null){
							key.cancel();
							if(key.channel() != null){
								key.channel().close();
							}
						}
					}
				}
			}catch(Throwable t){
				t.printStackTrace();
			}
		}
		//selector關閉後會自動釋放裏面管理的資源
		if(selector != null)
			try{
				selector.close();
			}catch (Exception e) {
				e.printStackTrace();
			}
	}
	private void handleInput(SelectionKey key) throws IOException{
		if(key.isValid()){
			//處理新接入的請求消息
			if(key.isAcceptable()){
				ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
				//通過ServerSocketChannel的accept創建SocketChannel實例
				//完成該操作意味着完成TCP三次握手，TCP物理鏈路正式建立
				SocketChannel sc = ssc.accept();
				//設置爲非阻塞的
				sc.configureBlocking(false);
				//註冊爲讀
				sc.register(selector, SelectionKey.OP_READ);
			}
			//讀消息
			if(key.isReadable()){
				SocketChannel sc = (SocketChannel) key.channel();
				//創建ByteBuffer，並開闢一個1M的緩衝區
				ByteBuffer buffer = ByteBuffer.allocate(1024);
				//讀取請求碼流，返回讀取到的字節數
				int readBytes = sc.read(buffer);
				//讀取到字節，對字節進行編解碼
				if(readBytes>0){
					//將緩衝區當前的limit設置爲position=0，用於後續對緩衝區的讀取操作
					buffer.flip();
					//根據緩衝區可讀字節數創建字節數組
					byte[] bytes = new byte[buffer.remaining()];
					//將緩衝區可讀字節數組複製到新建的數組中
					buffer.get(bytes);
					String expression = new String(bytes,"UTF-8");
					System.out.println("服務器收到消息：" + expression);
					//處理數據
					String result = null;
					try{
						result = Calculator.cal(expression).toString();
					}catch(Exception e){
						result = "計算錯誤：" + e.getMessage();
					}
					//發送應答消息
					doWrite(sc,result);
				}
				//沒有讀取到字節 忽略
//				else if(readBytes==0);
				//鏈路已經關閉，釋放資源
				else if(readBytes<0){
					key.cancel();
					sc.close();
				}
			}
		}
	}
	//異步發送應答消息
	private void doWrite(SocketChannel channel,String response) throws IOException{
		//將消息編碼爲字節數組
		byte[] bytes = response.getBytes();
		//根據數組容量創建ByteBuffer
		ByteBuffer writeBuffer = ByteBuffer.allocate(bytes.length);
		//將字節數組複製到緩衝區
		writeBuffer.put(bytes);
		//flip操作
		writeBuffer.flip();
		//發送緩衝區的字節數組
		channel.write(writeBuffer);
		//****此處不含處理“寫半包”的代碼
	}
}

可以看到，創建NIO服務端的主要步驟如下：

打開ServerSocketChannel，監聽客戶端連接
綁定監聽端口，設置連接爲非阻塞模式
創建Reactor線程，創建多路複用器並啓動線程
將ServerSocketChannel註冊到Reactor線程中的Selector上，監聽ACCEPT事件
Selector輪詢準備就緒的key
Selector監聽到新的客戶端接入，處理新的接入請求，完成TCP三次握手，簡歷物理鏈路
設置客戶端鏈路爲非阻塞模式
將新接入的客戶端連接註冊到Reactor線程的Selector上，監聽讀操作，讀取客戶端發送的網絡消息
異步讀取客戶端消息到緩衝區
對Buffer編解碼，處理半包消息，將解碼成功的消息封裝成Task
將應答消息編碼爲Buffer，調用SocketChannel的write將消息異步發送給客戶端

因爲應答消息的發送，SocketChannel也是異步非阻塞的，所以不能保證一次能吧需要發送的數據發送完，此時就會出現寫半包的問題。我們需要註冊寫操作，不斷輪詢Selector將沒有發送完的消息發送完畢，然後通過Buffer的hasRemain()方法判斷消息是否發送完成。

客戶端代碼：


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：

package com.anxpp.io.calculator.nio;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;
/**
 * NIO客戶端
 */
public class ClientHandle implements Runnable{
	private String host;
	private int port;
	private Selector selector;
	private SocketChannel socketChannel;
	private volatile boolean started;
 
	public ClientHandle(String ip,int port) {
		this.host = ip;
		this.port = port;
		try{
			//創建選擇器
			selector = Selector.open();
			//打開監聽通道
			socketChannel = SocketChannel.open();
			//如果爲 true，則此通道將被置於阻塞模式；如果爲 false，則此通道將被置於非阻塞模式
			socketChannel.configureBlocking(false);//開啓非阻塞模式
			started = true;
		}catch(IOException e){
			e.printStackTrace();
			System.exit(1);
		}
	}
	public void stop(){
		started = false;
	}
	@Override
	public void run() {
		try{
			doConnect();
		}catch(IOException e){
			e.printStackTrace();
			System.exit(1);
		}
		//循環遍歷selector
		while(started){
			try{
				//無論是否有讀寫事件發生，selector每隔1s被喚醒一次
				selector.select(1000);
				//阻塞,只有當至少一個註冊的事件發生的時候纔會繼續.
//				selector.select();
				Set<SelectionKey> keys = selector.selectedKeys();
				Iterator<SelectionKey> it = keys.iterator();
				SelectionKey key = null;
				while(it.hasNext()){
					key = it.next();
					it.remove();
					try{
						handleInput(key);
					}catch(Exception e){
						if(key != null){
							key.cancel();
							if(key.channel() != null){
								key.channel().close();
							}
						}
					}
				}
			}catch(Exception e){
				e.printStackTrace();
				System.exit(1);
			}
		}
		//selector關閉後會自動釋放裏面管理的資源
		if(selector != null)
			try{
				selector.close();
			}catch (Exception e) {
				e.printStackTrace();
			}
	}
	private void handleInput(SelectionKey key) throws IOException{
		if(key.isValid()){
			SocketChannel sc = (SocketChannel) key.channel();
			if(key.isConnectable()){
				if(sc.finishConnect());
				else System.exit(1);
			}
			//讀消息
			if(key.isReadable()){
				//創建ByteBuffer，並開闢一個1M的緩衝區
				ByteBuffer buffer = ByteBuffer.allocate(1024);
				//讀取請求碼流，返回讀取到的字節數
				int readBytes = sc.read(buffer);
				//讀取到字節，對字節進行編解碼
				if(readBytes>0){
					//將緩衝區當前的limit設置爲position=0，用於後續對緩衝區的讀取操作
					buffer.flip();
					//根據緩衝區可讀字節數創建字節數組
					byte[] bytes = new byte[buffer.remaining()];
					//將緩衝區可讀字節數組複製到新建的數組中
					buffer.get(bytes);
					String result = new String(bytes,"UTF-8");
					System.out.println("客戶端收到消息：" + result);
				}
				//沒有讀取到字節 忽略
//				else if(readBytes==0);
				//鏈路已經關閉，釋放資源
				else if(readBytes<0){
					key.cancel();
					sc.close();
				}
			}
		}
	}
	//異步發送消息
	private void doWrite(SocketChannel channel,String request) throws IOException{
		//將消息編碼爲字節數組
		byte[] bytes = request.getBytes();
		//根據數組容量創建ByteBuffer
		ByteBuffer writeBuffer = ByteBuffer.allocate(bytes.length);
		//將字節數組複製到緩衝區
		writeBuffer.put(bytes);
		//flip操作
		writeBuffer.flip();
		//發送緩衝區的字節數組
		channel.write(writeBuffer);
		//****此處不含處理“寫半包”的代碼
	}
	private void doConnect() throws IOException{
		if(socketChannel.connect(new InetSocketAddress(host,port)));
		else socketChannel.register(selector, SelectionKey.OP_CONNECT);
	}
	public void sendMsg(String msg) throws Exception{
		socketChannel.register(selector, SelectionKey.OP_READ);
		doWrite(socketChannel, msg);
	}
}

測試程序：


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

三、AIO

與NIO不同，當進行讀寫操作時，只須直接調用API的read或write方法即可。這兩種方法均爲異步的，對於讀操作而言，當有流可讀取時，操作系統會將可讀的流傳入read方法的緩衝區，並通知應用程序；對於寫操作而言，當操作系統將write方法傳遞的流寫入完畢時，操作系統主動通知應用程序。即可以理解爲，read/write方法都是異步的，完成後會主動調用回調函數。在JDK1.7中，這部分內容被稱作NIO.2，主要在java.nio.channels包下增加了下面四個異步通道：

AsynchronousSocketChannel
AsynchronousServerSocketChannel
AsynchronousFileChannel
AsynchronousDatagramChannel

其中的read/write方法，會返回一個帶回調函數的對象，當執行完讀取/寫入操作後，直接調用回調函數。

3.1、Server端代碼
Server：

/**
 * AIO服務端
 */
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：

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() {
        //CountDownLatch初始化
        //它的作用：在完成一組正在執行的操作之前，允許當前的現場一直阻塞
        //此處，讓現場在此阻塞，防止服務端執行完成後退出
        //也可以使用while(true)+sleep 
        //生成環境就不需要擔心這個問題，以爲服務端是不會退出的
        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;
//作爲handler接收客戶端連接
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);
        //創建新的Buffer
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        //異步讀  第三個參數爲接收消息回調的業務Handler
        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) {
        //flip操作
        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();
        //異步寫數據 參數與前面的read一樣
        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{
                    //創建新的Buffer
                    ByteBuffer readBuffer = ByteBuffer.allocate(1024);
                    //異步讀  第三個參數爲接收消息回調的業務Handler
                    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() {
        //創建CountDownLatch等待
        latch = new CountDownLatch(1);
        //發起異步連接操作，回調參數就是這個類本身，如果連接成功會回調completed方法
        clientChannel.connect(new InetSocketAddress(host, port), this, this);
        try {
            latch.await();
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        try {
            clientChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //連接服務器成功
    //意味着TCP三次握手完成
    @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：

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類，然後開闢大量線程，並使用構造方法創建很多的客戶端測試。

4、各種I/O的對比

BIO是一個連接一個線程。

NIO是一個請求一個線程。

AIO是一個有效請求一個線程。

先來個例子理解一下概念，以銀行取款爲例：

同步：自己親自出馬持銀行卡到銀行取錢（使用同步IO時，Java自己處理IO讀寫）；
異步：委託一小弟拿銀行卡到銀行取錢，然後給你（使用異步IO時，Java將IO讀寫委託給OS處理，需要將數據緩衝區地址和大小傳給OS(銀行卡和密碼)，OS需要支持異步IO操作API）；
阻塞： ATM排隊取款，你只能等待（使用阻塞IO時，Java調用會一直阻塞到讀寫完成才返回）；
非阻塞：櫃檯取款，取個號，然後坐在椅子上做其它事，等號廣播會通知你辦理，沒到號你就不能去，你可以不斷問大堂經理排到了沒有，大堂經理如果說還沒到你就不能去（使用非阻塞IO時，如果不能讀寫Java調用會馬上返回，當IO事件分發器會通知可讀寫時再繼續進行讀寫，不斷循環直到讀寫完成）

AIO是真正的異步非阻塞的，所以，在面對超級大量的客戶端，更能得心應手。

下面就比較一下，幾種I/O編程的優缺點。

具體選擇什麼樣的模型或者NIO框架，完全基於業務的實際應用場景和性能需求，如果客戶端很少，服務器負荷不重，就沒有必要選擇開發起來相對不那麼簡單的NIO做服務端；相反，就應考慮使用NIO或者相關的框架了。

Java對BIO、NIO、AIO的支持：

Java BIO ：同步並阻塞，服務器實現模式爲一個連接一個線程，即客戶端有連接請求時服務器端就需要啓動一個線程進行處理，如果這個連接不做任何事情會造成不必要的線程開銷，當然可以通過線程池機制改善。
Java NIO ：同步非阻塞，服務器實現模式爲一個請求一個線程，即客戶端發送的連接請求都會註冊到多路複用器上，多路複用器輪詢到連接有I/O請求時才啓動一個線程進行處理。
Java AIO(NIO.2) ：異步非阻塞，服務器實現模式爲一個有效請求一個線程，客戶端的I/O請求都是由OS先完成了再通知服務器應用去啓動線程進行處理，

BIO、NIO、AIO適用場景分析:

BIO方式適用於連接數目比較小且固定的架構，這種方式對服務器資源要求比較高，併發侷限於應用中，JDK1.4以前的唯一選擇，但程序直觀簡單易理解。
NIO方式適用於連接數目多且連接比較短（輕操作）的架構，比如聊天服務器，併發侷限於應用中，編程比較複雜，JDK1.4開始支持。
AIO方式使用於連接數目多且連接比較長（重操作）的架構，比如相冊服務器，充分調用OS參與併發操作，編程比較複雜，JDK7開始支持。

另外，I/O屬於底層操作，需要操作系統支持，併發也需要操作系統的支持，所以性能方面不同操作系統差異會比較明顯。

在高性能的I/O設計中，有兩個比較著名的模式Reactor和Proactor模式，其中Reactor模式用於同步I/O，而Proactor運用於異步I/O操作。

轉載地址： https://blog.csdn.net/anxpp/article/details/51512200

Java 網絡IO編程總結

一、BIO編程

二、NIO編程

三、AIO

4、各種I/O的對比

軟件測試的八個原則

如何提高SQL查詢的效率？

技術原理和技術本質

“釣魚”來學習Linux的五種IO模型

拿個栗子來看看v-if 和v-show區別

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

Java 網絡IO編程總結

一、BIO編程

二 、NIO編程

三、AIO

4、各種I/O的對比

二、NIO編程