BIO/NIO/AIO

幾個概念

阻塞IO 和非阻塞IO 這兩個概念是程序級別的。主要描述的是程序請求操作系統IO操作後，如果IO資源沒有準備好，那麼程序該如何處理的問題：前者等待；後者繼續執行（但是使用線程一直輪詢，直到有
IO資源準備好了）。

同步IO 和 異步IO，這兩個概念是操作系統級別的。主要描述的是操作系統在收到程序請求IO操作後，如果IO資源沒有準備好，該如何響應程序的問題：前者不響應，直到IO資源準備好以後；後者返回一個標記（好讓程序和自己知道以後的數據往哪裏通知），當IO資源準備好以後，再用事件機制返回給程序。

案例：小明去銀行取錢
同步：自己親自出馬持銀行卡到銀行取錢（使用同步IO時，Java自己處理IO讀寫）。

異步：委託一小弟拿銀行卡到銀行取錢，然後給你（使用異步IO時，Java將IO讀寫委託給OS處理，需要將數據緩衝區地址和大小傳給OS(銀行卡和密碼)，OS需要支持異步IO操作API）。

阻塞： ATM排隊取款，你只能等待（使用阻塞IO時，Java調用會一直阻塞到讀寫完成才返回）。

非阻塞：櫃檯取款，取個號，然後坐在椅子上做其它事，等號廣播會通知你辦理，沒到號你就不能去，你可以不斷問大堂經理排到了沒有，大堂經理如果說還沒到你就不能去（使用非阻塞IO時，如果不能讀寫Java調用會馬上返回，當IO事件分發器會通知可讀寫時再繼續進行讀寫，不斷循環直到讀寫完成）。

BIO

BIO是什麼？

即Blocking IO 同步並阻塞，服務器實現模式爲一個連接一個線程，即客戶端有連接請求時服務器端就需要啓動一個線程進行處理，如果這個連接不做任何事情會造成不必要的線程開銷，當然可以通過線程池機制改善。 #### BIO通信方式的特點 1、一個線程負責連接，多線程則爲每一個接入開啓一個線程。 2、一個請求一個應答。 3、請求之後應答之前客戶端會一直等待（阻塞）。

服務端

public class Server {
	public static final int PORT = 20006;

	public static void main(String[] args) throws IOException {
		ServerSocket server = null;
		try {
			server = new ServerSocket(PORT);
			System.out.println("Server is listening on " + PORT);
			while (true) {
				Socket client = null;
				client = server.accept();
				//單線程
				new BlockThread(Thread.currentThread(), client).block();
				//多線程
//				new Thread(new Handler(client)).start();
				//線程池
//				HandlerExecutor executor = new HandlerExecutor(10, 100);
//				executor.execute(new Handler(client));
			}

		} finally {
			if (server != null) {
				System.out.println("server is closed!");
				server.close();
			}
		}
	}
}

客戶端

public class Client {
	private static final int PORT = 20006;
	private static final String ADDR = "127.0.0.1";

	public static void main(String[] args) {
		client1();
		client2();
	}

	public static void client1() {
		Socket socket = null;

		try {
			socket = new Socket(ADDR, PORT);
			socket.setSoTimeout(2000);
			readWrite(socket, "first");
		} catch (SocketTimeoutException e) {
			System.out.println("first-server time out, exit!");
		} catch (IOException e) {
			e.printStackTrace();
		} finally {

			if (socket != null) {
				try {
					socket.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

	public static void client2() {
		Socket socket = null;

		try {
			socket = new Socket(ADDR, PORT);
			socket.setSoTimeout(10000);
			readWrite(socket, "second");
		} catch (SocketTimeoutException e) {
			System.out.println("second-server time out, exit!");
		} catch (IOException e) {
			e.printStackTrace();
		} finally {

			if (socket != null) {
				try {
					socket.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

	private static void readWrite(Socket socket, String clientName) throws IOException {
		BufferedReader in = null;
		PrintStream out = null;
		in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
		out = new PrintStream(socket.getOutputStream());
		out.println("1:Hello server!Client-" + clientName);
		out.println("2:Hello server!Client-" + clientName);
		out.println("bye");
		String line = in.readLine();
		System.out.println("Receive from server: " + line);
		if (in != null) {
			try {
				in.close();
				System.out.println(clientName + ":client from server in close!");
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		if (out != null) {
			out.close();
			System.out.println(clientName + ":client-first from server out close!");
		}
	}
}

結合剛纔那段熟悉的代碼理解同步阻塞（BIO） serverSocket.accepte() 這個方法要一直等待着，也就是說下面的代碼在它沒有執行完就不會執行。 socket.getInputStream()得到的輸入流輸入輸出流會阻塞：當read時，無數據或沒有完全讀完時，此時會阻塞。誰用誰接受，必須等待數據接受完畢以後，才能處理業務邏輯

NIO

即non-blocking IO，也叫做new IO，因爲是NIO是JDK 1.4的java.nio.*包中引入的新I/O庫，目的是提高速度，也是對之前的BIO一個補充完善。
NIO的三個重點，重中之重的是：

1、 channel（通道）

連接data數據與buffer緩存區的橋樑。
既可以從通道中讀取數據，又可以寫數據到通道。但流的讀寫通常是單向的。
通道可以異步地讀寫。
通道中的數據總是要先讀到一個Buffer，或者總是要從一個Buffer中寫入。

2、 Buffer（緩衝區）

用於和NIO通道進行交互。如圖所示，數據是從通道讀入緩衝區，從緩衝區寫入到通道中的。

3、 Selector（選擇器）

是Java NIO中能夠檢測一到多個NIO通道，並能夠知曉通道是否爲諸如讀寫事件做好準備的組件，如此一個單獨的線程可以管理多個channel，從而管理多個連接。

channel（通道）

Java NIO的通道類似流，但又有些不同：
既可以從通道中讀取數據，又可以寫數據到通道。但流的讀寫通常是單向的。
通道可以異步地讀寫。
通道中的數據總是要先讀到一個Buffer，或者總是要從一個Buffer中寫入。
正如上面所說，從通道讀取數據到緩衝區，從緩衝區寫入數據到通道。如下圖所示：

Channel的實現
這些是Java NIO中最重要的通道的實現：
1、FileChannel 從文件中讀寫數據。
2、DatagramChannel 能通過UDP讀寫網絡中的數據。
3、SocketChannel 能通過TCP讀寫網絡中的數據。
4、ServerSocketChannel可以監聽新進來的TCP連接，像Web服務器那樣。對每一個新進來的連接都會創建一個SocketChannel。

Buffer（緩衝區）

Java NIO中的Buffer用於和NIO通道進行交互。如你所知，數據是從通道讀入緩衝區，從緩衝區寫入到通道中的。
緩衝區本質上是一塊可以寫入數據，然後可以從中讀取數據的內存。這塊內存被包裝成NIO Buffer對象，並提供了一組方法，用來方便的訪問該塊內存。

Buffer的基本用法
使用Buffer讀寫數據一般遵循以下四個步驟：
1、寫入數據到Buffer
2、調用flip()方法
3、從Buffer中讀取數據
4、調用clear()方法或者compact()方法

當向buffer寫入數據時，buffer會記錄下寫了多少數據。一旦要讀取數據，需要通過flip()方法將Buffer從寫模式切換到讀模式。在讀模式下，可以讀取之前寫入到buffer的所有數據。
一旦讀完了所有的數據，就需要清空緩衝區，讓它可以再次被寫入。有兩種方式能清空緩衝區：調用clear()或compact()方法。clear()方法會清空整個緩衝區。compact()方法只會清除已經讀過的數據。任何未讀的數據都被移到緩衝區的起始處，新寫入的數據將放到緩衝區未讀數據的後面。

RandomAccessFile aFile = new RandomAccessFile("data/nio-data.txt", "rw");
FileChannel inChannel = aFile.getChannel();

//create buffer with capacity of 48 bytes
ByteBuffer buf = ByteBuffer.allocate(48);

int bytesRead = inChannel.read(buf); //read into buffer.
while (bytesRead != -1) {

  buf.flip();  //make buffer ready for read

  while(buf.hasRemaining()){
      System.out.print((char) buf.get()); // read 1 byte at a time
  }

  buf.clear(); //make buffer ready for writing
  bytesRead = inChannel.read(buf);
}
aFile.close();

緩衝區本質上是一塊可以寫入數據，然後可以從中讀取數據的內存。這塊內存被包裝成NIO Buffer對象，並提供了一組方法，用來方便的訪問該塊內存。爲了理解Buffer的工作原理，需要熟悉它的三個屬性： capacity: 作爲一個內存塊，Buffer有一個固定的大小值，也叫“capacity”.你只能往裏寫capacity個byte、long，char等類型。一旦Buffer滿了，需要將其清空（通過讀數據或者清除數據）才能繼續寫數據往裏寫數據。 position: 當你寫數據到Buffer中時，position表示當前的位置。初始的position值爲0.當一個byte、long等數據寫到Buffer後， position會向前移動到下一個可插入數據的Buffer單元。position最大可爲capacity – 1. 當讀取數據時，也是從某個特定位置讀。當將Buffer從寫模式切換到讀模式，position會被重置爲0. 當從Buffer的position處讀取數據時，position向前移動到下一個可讀的位置。 limit: 在寫模式下，Buffer的limit表示你最多能往Buffer裏寫多少數據。寫模式下，limit等於Buffer的capacity。當切換Buffer到讀模式時， limit表示你最多能讀到多少數據。因此，當切換Buffer到讀模式時，limit會被設置成寫模式下的position值。換句話說，你能讀到之前寫入的所有數據（limit被設置成已寫數據的數量，這個值在寫模式下就是position）

Java NIO 有以下Buffer類型

ByteBuffer
MappedByteBuffer
CharBuffer
DoubleBuffer
FloatBuffer
IntBuffer
LongBuffer
ShortBuffer
Buffer的分配

要想獲得一個Buffer對象首先要進行分配。每一個Buffer類都有一個allocate方法。下面是一個分配48字節capacity的ByteBuffer的例子。

ByteBuffer buf = ByteBuffer.allocate(48);

這是分配一個可存儲1024個字符的CharBuffer：

CharBuffer buf = CharBuffer.allocate(1024);
向Buffer中寫數據

寫數據到Buffer有兩種方式：

從Channel寫到Buffer。
通過Buffer的put()方法寫到Buffer裏。
從Channel寫到Buffer的例子

int bytesRead = inChannel.read(buf); //read into buffer.
//通過put方法寫Buffer的例子：
buf.put(127);

put方法有很多版本，允許你以不同的方式把數據寫入到Buffer中。例如，寫到一個指定的位置，或者把一個字節數組寫入到Buffer。更多Buffer實現的細節參考JavaDoc。

flip()方法

flip方法將Buffer從寫模式切換到讀模式。調用flip()方法會將position設回0，並將limit設置成之前position的值。

換句話說，position現在用於標記讀的位置，limit表示之前寫進了多少個byte、char等 —— 現在能讀取多少個byte、char等。

從Buffer中讀取數據

從Buffer中讀取數據有兩種方式：

從Buffer讀取數據到Channel。
使用get()方法從Buffer中讀取數據。

從Buffer讀取數據到Channel的例子：
//read from buffer into channel.
int bytesWritten = inChannel.write(buf);
使用get()方法從Buffer中讀取數據的例子
byte aByte = buf.get();

get方法有很多版本，允許你以不同的方式從Buffer中讀取數據。例如，從指定position讀取，或者從Buffer中讀取數據到字節數組。更多Buffer實現的細節參考JavaDoc。

rewind()方法

Buffer.rewind()將position設回0，所以你可以重讀Buffer中的所有數據。limit保持不變，仍然表示能從Buffer中讀取多少個元素（byte、char等）。

public final Buffer rewind() {
        position = 0;
        mark = -1;
        return this;
    }

clear()與compact()方法

一旦讀完Buffer中的數據，需要讓Buffer準備好再次被寫入。可以通過clear()或compact()方法來完成。

如果調用的是clear()方法，position將被設回0，limit被設置成 capacity的值。換句話說，Buffer 被清空了。Buffer中的數據並未清除，只是這些標記告訴我們可以從哪裏開始往Buffer裏寫數據。

如果Buffer中有一些未讀的數據，調用clear()方法，數據將“被遺忘”，意味着不再有任何標記會告訴你哪些數據被讀過，哪些還沒有。

如果Buffer中仍有未讀的數據，且後續還需要這些數據，但是此時想要先先寫些數據，那麼使用compact()方法。

compact()方法將所有未讀的數據拷貝到Buffer起始處。然後將position設到最後一個未讀元素正後面。limit屬性依然像clear()方法一樣，設置成capacity。現在Buffer準備好寫數據了，但是不會覆蓋未讀的數據。

mark()與reset()方法

通過調用Buffer.mark()方法，可以標記Buffer中的一個特定position。之後可以通過調用Buffer.reset()方法恢復到這個position。例如：

buffer.mark();
//call buffer.get() a couple of times, e.g. during parsing.
buffer.reset();  //set position back to mark.

equals()與compareTo()方法

可以使用equals()和compareTo()方法比較兩個Buffer。

equals()

當滿足下列條件時，表示兩個Buffer相等：

有相同的類型（byte、char、int等）。
Buffer中剩餘的byte、char等的個數相等。
Buffer中所有剩餘的byte、char等都相同。
如你所見，equals只是比較Buffer的一部分，不是每一個在它裏面的元素都比較。實際上，它只比較Buffer中的剩餘元素。

compareTo()方法

compareTo()方法比較兩個Buffer的剩餘元素(byte、char等)，如果滿足下列條件，則認爲一個Buffer“小於”另一個Buffer：

第一個不相等的元素小於另一個Buffer中對應的元素。
所有元素都相等，但第一個Buffer比另一個先耗盡(第一個Buffer的元素個數比另一個少)。

channel（通道）

Java NIO的通道類似流，但又有些不同：
既可以從通道中讀取數據，又可以寫數據到通道。但流的讀寫通常是單向的。
通道可以異步地讀寫。
通道中的數據總是要先讀到一個Buffer，或者總是要從一個Buffer中寫入。
正如上面所說，從通道讀取數據到緩衝區，從緩衝區寫入數據到通道。
Channel的實現

這些是Java NIO中最重要的通道的實現：

FileChannel
DatagramChannel
SocketChannel
ServerSocketChannel
FileChannel 從文件中讀寫數據。

DatagramChannel 能通過UDP讀寫網絡中的數據。

SocketChannel 能通過TCP讀寫網絡中的數據。

ServerSocketChannel可以監聽新進來的TCP連接，像Web服務器那樣。對每一個新進來的連接都會創建一個SocketChannel。

基本的 Channel 示例

RandomAccessFile aFile = new RandomAccessFile("data/nio-data.txt", "rw");
FileChannel inChannel = aFile.getChannel();

ByteBuffer buf = ByteBuffer.allocate(48);

int bytesRead = inChannel.read(buf);
while (bytesRead != -1) {

System.out.println("Read " + bytesRead);
buf.flip();

while(buf.hasRemaining()){
System.out.print((char) buf.get());
}

buf.clear();
bytesRead = inChannel.read(buf);
}
aFile.close();

Selector（選擇器）

Selector（選擇器）是Java NIO中能夠檢測一到多個NIO通道，並能夠知曉通道是否爲諸如讀寫事件做好準備的組件。這樣，一個單獨的線程可以管理多個channel，從而管理多個網絡連接。
Selector的創建

Selector selector = Selector.open();

向Selector註冊通道

channel.configureBlocking(false);  
SelectionKey key = channel.register(selector,  
Selectionkey.OP_READ);

與Selector一起使用時，Channel必須處於非阻塞模式下。這意味着不能將FileChannel與Selector一起使用，因爲FileChannel不能切換到非阻塞模式。而套接字通道都可以。
注意register()方法的第二個參數。這是一個“interest集合”，意思是在通過Selector監聽Channel時對什麼事件感興趣。可以監聽四種不同類型的事件：
Connect、
Accept、
Read、
Write
通道觸發了一個事件意思是該事件已經就緒。所以，某個channel成功連接到另一個服務器稱爲“連接就緒”。一個server socket channel準備好接收新進入的連接稱爲“接收就緒”。一個有數據可讀的通道可以說是“讀就緒”。等待寫數據的通道可以說是“寫就緒”。
這四種事件用SelectionKey的四個常量來表示：
SelectionKey.OP_CONNECT
SelectionKey.OP_ACCEPT
SelectionKey.OP_READ
SelectionKey.OP_WRITE
如果你對不止一種事件感興趣，那麼可以用“位或”操作符將常量連接起來，如下：

int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

SelectionKey

當向Selector註冊Channel時，register()方法會返回一個SelectionKey對象。這個對象包含了一些屬性：
interest集合
ready集合
Channel
Selector

interest集合

就像向Selector註冊通道一節中所描述的，interest集合是你所選擇的感興趣的事件集合。可以通過SelectionKey讀寫interest集合：

public final boolean isAcceptable() {
        return (readyOps() & OP_ACCEPT) != 0;
    }
 public final boolean isConnectable() {
        return (readyOps() & OP_CONNECT) != 0;
    }
public final boolean isReadable() {
        return (readyOps() & OP_READ) != 0;
    }
public final boolean isWritable() {
        return (readyOps() & OP_WRITE) != 0;
    }

ready集合

ready 集合是通道已經準備就緒的操作的集合。在一次選擇(Selection)之後，你會首先訪問這個ready set。
int readySet = selectionKey.readyOps();

可以用像檢測interest集合那樣的方法，來檢測channel中什麼事件或操作已經就緒。但是，也可以使用以下四個方法，它們都會返回一個布爾類型：

selectionKey.isAcceptable();
selectionKey.isConnectable();
selectionKey.isReadable();
selectionKey.isWritable();

Channel + Selector

從SelectionKey訪問Channel和Selector很簡單。如下：

Channel  channel  = selectionKey.channel();
Selector selector = selectionKey.selector();

服務端

private static final int PORT = 20006;
	private static final int TIMEOUT = 3000;
	public static void main(String[] args) {
		Selector selector = null;
		ServerSocketChannel server = null;
		try {
			selector = Selector.open();                                         server = ServerSocketChannel.open();
			server.socket().bind(new InetSocketAddress(PORT));                  server.configureBlocking(false);
			server.register(selector, SelectionKey.OP_ACCEPT);
			while (true) {
				if (selector.select(TIMEOUT) == 0) {
					System.out.println("==");
					continue;
				}
				Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
				while (iter.hasNext()) {
					SelectionKey key = iter.next();
					if (key.isAcceptable()) {ServerUtil.handleAccept(key);}
					if (key.isReadable()) {ServerUtil.handleRead(key);}
					if (key.isWritable() && key.isValid()) {ServerUtil.handleWrite(key);}
					if (key.isConnectable()) {System.out.println("isConnectable = true");}
					iter.remove();
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (selector != null) {selector.close();}
				if (server != null) {server.close();}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}


	private static final int BUF_SIZE = 1024;
	public static void handleAccept(SelectionKey key) throws IOException {
		ServerSocketChannel ssChannel = (ServerSocketChannel) key.channel();
		SocketChannel sc = ssChannel.accept();
		sc.configureBlocking(false);//非阻塞
		sc.register(key.selector(), SelectionKey.OP_READ, ByteBuffer.allocateDirect(BUF_SIZE));
	}

	public static void handleRead(SelectionKey key) throws IOException {
		SocketChannel sc = (SocketChannel) key.channel();
		ByteBuffer buf = (ByteBuffer) key.attachment();
		long bytesRead = sc.read(buf);
		while (bytesRead > 0) {
			buf.flip();
			while (buf.hasRemaining()) {
				System.out.print((char) buf.get());
			}
			System.out.println();
			buf.clear();
			bytesRead = sc.read(buf);
		}
		if (bytesRead == -1) {
			sc.close();
		}
	}

	public static void handleWrite(SelectionKey key) throws IOException {
		ByteBuffer buf = (ByteBuffer) key.attachment();
		buf.flip();
		SocketChannel sc = (SocketChannel) key.channel();
		while (buf.hasRemaining()) {
			sc.write(buf);
		}
		buf.compact();
	}

客戶端

public static void main(String[] args) {
		ByteBuffer buffer = ByteBuffer.allocate(1024);
		SocketChannel socketChannel = null;
		try {
			socketChannel = SocketChannel.open();
			socketChannel.configureBlocking(false);
			socketChannel.connect(new InetSocketAddress("localhost", 20006));
			if (socketChannel.finishConnect()) {
				int i = 0;
				while (true) {
					TimeUnit.SECONDS.sleep(1);
					String info = "I'm NIO-Client-First" + i++ + "-th information from client";
					buffer.clear();
					buffer.put(info.getBytes());
					buffer.flip();
					while (buffer.hasRemaining()) {
						System.out.println(buffer);
						socketChannel.write(buffer);
					}
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			try {
				if (socketChannel != null) {
					socketChannel.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

TomcatNio

指定 Protocol，初始化相應的 Endpoint，我們分析的是 NioEndpoint；
init 過程：在 NioEndpoint 中做 bind 操作(開啓 ServerSocketChannel、綁定地址、端口、設置 ServerSocketChannel 阻塞模式、初始化poller 線程數)；
start 過程：啓動 worker 線程池，啓動 1 個 Acceptor 和 2 個 Poller，當然它們都是默認值，可配；
Acceptor 獲取到新的連接後，getPoller0() 獲取其中一個 Poller，然後 register 到 Poller 中；
Poller 循環 selector.select(xxx)，如果有通道 readable，那麼在 processKey 中將其放到 worker 線程池中。

AIO

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

AsynchronousSocketChannel
AsynchronousServerSocketChannel
AsynchronousFileChannel
AsynchronousDatagramChannel

BIO是一個連接一個線程。
NIO是一個請求一個線程。
AIO是一個有效請求一個線程。

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

Java BIO ：同步並阻塞，服務器實現模式爲一個連接一個線程，即客戶端有連接請求時服務器端就需要啓動一個線程進行處理，如果這個連接不做任何事情會造成不必要的線程開銷，當然可以通過線程池機制改善。

Java NIO ：同步非阻塞，服務器實現模式爲一個請求一個線程，即客戶端發送的連接請求都會註冊到多路複用器上，多路複用器輪詢到連接有I/O請求時才啓動一個線程進行處理。

Java AIO(NIO.2) ：異步非阻塞，服務器實現模式爲一個有效請求一個線程，客戶端的I/O請求都是由OS先完成了再通知服務器應用去啓動線程進行處理

BIO/NIO/AIO

BIO/NIO/AIO

幾個概念

BIO

BIO是什麼？

NIO

1、 channel（通道）

2、 Buffer（緩衝區）

3、 Selector（選擇器）

channel（通道）

Buffer（緩衝區）

Java NIO 有以下Buffer類型

equals()與compareTo()方法

channel（通道）

Selector（選擇器）

SelectionKey

interest集合

ready集合

Channel + Selector

服務端

客戶端

TomcatNio

AIO

.NET開源強大、易於使用的緩存框架 - FusionCache

面試，有時候是個運氣活

Jasperreports+jaspersoft studio（二）：使用Parameters填充報表

Linux：redis連接命令

Mac升級系統後xcrun: error: invalid active developer path (/Library/Developer/CommandLineTools)及No Xcode

帶你瞭解Java註解

Mac連接遠程服務器：WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED!

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

linux以太網驅動總結