A. java中bio nio aio的區別和聯系
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先完成了再通知伺服器應用去啟動線程進行處理，
B. Java裡面標准IO和NIO有什麼不同
NIO 是 New I/O 的縮寫，因為它提供了更多改進，比如使用系統的方法改進讀寫性能，提供事件輪詢改進 Socket 的資源佔用等 。
NIO 基本上盡量用 native 方法實現功能，不過這些 native 方法都由 JVM 自動提供了實現不需要藉助第三方 dll / so 類庫。在 Java NIO 之前企業應用中想要達到高性能可能需要第三方 dll/so 類的協助，現在 JVM 自帶這些。
C. Java NIO和IO的區別
Java NIO和IO的主要區別如下：
1.NIO 的創建目的是為了讓 Java 程序員可以實現高速 I/O 而無需編寫自定義的本機代碼。NIO 將最耗時的 I/O 操作(即填充和提取緩沖區)轉移回操作系統，因而可以極大地提高速度。傳統的IO操作屬於阻塞型，嚴重影響程序的運行速度。
2,。流與塊的比較。原來的 I/O 庫(在 java.io.*中) 與 NIO 最重要的區別是數據打包和傳輸的方式。正如前面提到的，原來的 I/O 以流的方式處理數據，而 NIO 以塊的方式處理數據。
面向流 的 I/O 系統一次一個位元組地處理數據。一個輸入流產生一個位元組的數據，一個輸出流消費一個位元組的數據。為流式數據創建過濾器非常容易。鏈接幾個過濾器，以便每個過濾器只負責單個復雜處理機制的一部分，這樣也是相對簡單的。不利的一面是，面向流的 I/O 通常相當慢。
3.一個 面向塊 的 I/O 系統以塊的形式處理數據。每一個操作都在一步中產生或者消費一個數據塊。按塊處理數據比按(流式的)位元組處理數據要快得多。但是面向塊的 I/O 缺少一些面向流的 I/O 所具有的優雅性和簡單性。
D. Java中nio與普通io有什麼優勢
面向流與面向緩沖
Java NIO和IO之間第一個最大的區別是，IO是面向流的，NIO是面向緩沖區的。 Java IO面向流意味著每次從流中讀一個或多個位元組，直至讀取所有位元組，它們沒有被緩存在任何地方。此外，它不能前後移動流中的數據。如果需要前後移動從流中讀取的數據，需要先將它緩存到一個緩沖區。 Java NIO的緩沖導向方法略有不同。數據讀取到一個它稍後處理的緩沖區，需要時可在緩沖區中前後移動。這就增加了處理過程中的靈活性。但是，還需要檢查是否該緩沖區中包含所有您需要處理的數據。而且，需確保當更多的數據讀入緩沖區時，不要覆蓋緩沖區里尚未處理的數據。
阻塞與非阻塞IO
Java IO的各種流是阻塞的。這意味著，當一個線程調用read() 或 write()時，該線程被阻塞，直到有一些數據被讀取，或數據完全寫入。該線程在此期間不能再干任何事情了。 Java NIO的非阻塞模式，使一個線程從某通道發送請求讀取數據，但是它僅能得到目前可用的數據，如果目前沒有數據可用時，就什麼都不會獲取。而不是保持線程阻塞，所以直至數據變的可以讀取之前，該線程可以繼續做其他的事情。 非阻塞寫也是如此。一個線程請求寫入一些數據到某通道，但不需要等待它完全寫入，這個線程同時可以去做別的事情。 線程通常將非阻塞IO的空閑時間用於在其它通道上執行IO操作，所以一個單獨的線程現在可以管理多個輸入和輸出通道（channel）。
選擇器（Selectors）
Java NIO的選擇器允許一個單獨的線程來監視多個輸入通道，你可以注冊多個通道使用一個選擇器，然後使用一個單獨的線程來「選擇」通道：這些通道里已經有可以處理的輸入，或者選擇已准備寫入的通道。這種選擇機制，使得一個單獨的線程很容易來管理多個通道。
NIO和IO如何影響應用程序的設計
無論您選擇IO或NIO工具箱，可能會影響您應用程序設計的以下幾個方面：
1.對NIO或IO類的API調用。
2.數據處理。
3.用來處理數據的線程數。
API調用
當然，使用NIO的API調用時看起來與使用IO時有所不同，但這並不意外，因為並不是僅從一個InputStream逐位元組讀取，而是數據必須先讀入緩沖區再處理。
數據處理
使用純粹的NIO設計相較IO設計，數據處理也受到影響。
E. Java NIO與IO的區別和比較
J2SE1.4以上版本中發布了全新的I/O類庫。本文將通過一些實例來簡單介紹NIO庫提供的一些新特性：非阻塞I/O，字元轉換，緩沖以及通道。
一. 介紹NIO
NIO包（java.nio.*）引入了四個關鍵的抽象數據類型，它們共同解決傳統的I/O類中的一些問題。
1． Buffer：它是包含數據且用於讀寫的線形表結構。其中還提供了一個特殊類用於內存映射文件的I/O操作。
2． Charset：它提供Unicode字元串影射到位元組序列以及逆影射的操作。
3． Channels：包含socket，file和pipe三種管道，它實際上是雙向交流的通道。
4． Selector：它將多元非同步I/O操作集中到一個或多個線程中（它可以被看成是Unix中select（）函數或Win32中WaitForSingleEvent（）函數的面向對象版本）。
二. 回顧傳統
在介紹NIO之前，有必要了解傳統的I/O操作的方式。以網路應用為例，傳統方式需要監聽一個ServerSocket，接受請求的連接為其提供服務（服務通常包括了處理請求並發送響應）圖一是伺服器的生命周期圖，其中標有粗黑線條的部分表明會發生I/O阻塞。
圖一
可以分析創建伺服器的每個具體步驟。首先創建ServerSocket
ServerSocket server=new ServerSocket（10000）；
然後接受新的連接請求
Socket newConnection=server.accept（）；
對於accept方法的調用將造成阻塞，直到ServerSocket接受到一個連接請求為止。一旦連接請求被接受，伺服器可以讀客戶socket中的請求。
InputStream in = newConnection.getInputStream();
InputStreamReader reader = new InputStreamReader(in);
BufferedReader buffer = new BufferedReader(reader);
Request request = new Request();
while(!request.isComplete()) {
String line = buffer.readLine();
request.addLine(line);
}
這樣的操作有兩個問題，首先BufferedReader類的readLine（）方法在其緩沖區未滿時會造成線程阻塞，只有一定數據填滿了緩沖區或者客戶關閉了套接字，方法才會返回。其次，它回產生大量的垃圾，BufferedReader創建了緩沖區來從客戶套接字讀入數據，但是同樣創建了一些字元串存儲這些數據。雖然BufferedReader內部提供了StringBuffer處理這一問題，但是所有的String很快變成了垃圾需要回收。
同樣的問題在發送響應代碼中也存在
Response response = request.generateResponse();
OutputStream out = newConnection.getOutputStream();
InputStream in = response.getInputStream()；
int ch；
while(-1 != (ch = in.read())) {
out.write(ch);
}
newConnection.close();
類似的，讀寫操作被阻塞而且向流中一次寫入一個字元會造成效率低下，所以應該使用緩沖區，但是一旦使用緩沖，流又會產生更多的垃圾。
傳統的解決方法
通常在Java中處理阻塞I/O要用到線程（大量的線程）。一般是實現一個線程池用來處理請求，如圖二
圖二
線程使得伺服器可以處理多個連接，但是它們也同樣引發了許多問題。每個線程擁有自己的棧空間並且佔用一些CPU時間，耗費很大，而且很多時間是浪費在阻塞的I/O操作上，沒有有效的利用CPU。
三. 新I/O
1． Buffer
傳統的I/O不斷的浪費對象資源（通常是String）。新I/O通過使用Buffer讀寫數據避免了資源浪費。Buffer對象是線性的，有序的數據集合，它根據其類別只包含唯一的數據類型。
java.nio.Buffer 類描述
java.nio.ByteBuffer 包含位元組類型。 可以從ReadableByteChannel中讀在 WritableByteChannel中寫
java.nio.MappedByteBuffer 包含位元組類型，直接在內存某一區域映射
java.nio.CharBuffer 包含字元類型，不能寫入通道
java.nio.DoubleBuffer 包含double類型，不能寫入通道
java.nio.FloatBuffer 包含float類型
java.nio.IntBuffer 包含int類型
java.nio.LongBuffer 包含long類型
java.nio.ShortBuffer 包含short類型
可以通過調用allocate(int capacity)方法或者allocateDirect(int capacity)方法分配一個Buffer。特別的，你可以創建MappedBytesBuffer通過調用FileChannel.map(int mode,long position,int size)。直接（direct）buffer在內存中分配一段連續的塊並使用本地訪問方法讀寫數據。非直接(nondirect)buffer通過使用Java中的數組訪問代碼讀寫數據。有時候必須使用非直接緩沖例如使用任何的wrap方法（如ByteBuffer.wrap(byte[])）在Java數組基礎上創建buffer。
2． 字元編碼
向ByteBuffer中存放數據涉及到兩個問題：位元組的順序和字元轉換。ByteBuffer內部通過ByteOrder類處理了位元組順序問題，但是並沒有處理字元轉換。事實上，ByteBuffer沒有提供方法讀寫String。
Java.nio.charset.Charset處理了字元轉換問題。它通過構造CharsetEncoder和CharsetDecoder將字元序列轉換成位元組和逆轉換。
3． 通道(Channel)
你可能注意到現有的java.io類中沒有一個能夠讀寫Buffer類型，所以NIO中提供了Channel類來讀寫Buffer。通道可以認為是一種連接，可以是到特定設備，程序或者是網路的連接。通道的類等級結構圖如下
圖三
圖中ReadableByteChannel和WritableByteChannel分別用於讀寫。
GatheringByteChannel可以從使用一次將多個Buffer中的數據寫入通道，相反的，ScatteringByteChannel則可以一次將數據從通道讀入多個Buffer中。你還可以設置通道使其為阻塞或非阻塞I/O操作服務。
為了使通道能夠同傳統I/O類相容，Channel類提供了靜態方法創建Stream或Reader
4． Selector
在過去的阻塞I/O中，我們一般知道什麼時候可以向stream中讀或寫，因為方法調用直到stream准備好時返回。但是使用非阻塞通道，我們需要一些方法來知道什麼時候通道准備好了。在NIO包中，設計Selector就是為了這個目的。SelectableChannel可以注冊特定的事件，而不是在事件發生時通知應用，通道跟蹤事件。然後，當應用調用Selector上的任意一個selection方法時，它查看注冊了的通道看是否有任何感興趣的事件發生。圖四是selector和兩個已注冊的通道的例子
圖四
並不是所有的通道都支持所有的操作。SelectionKey類定義了所有可能的操作位，將要用兩次。首先，當應用調用SelectableChannel.register(Selector sel,int op)方法注冊通道時，它將所需操作作為第二個參數傳遞到方法中。然後，一旦SelectionKey被選中了，SelectionKey的readyOps()方法返回所有通道支持操作的數位的和。SelectableChannel的validOps方法返回每個通道允許的操作。注冊通道不支持的操作將引發IllegalArgumentException異常。下表列出了SelectableChannel子類所支持的操作。
ServerSocketChannel OP_ACCEPT
SocketChannel OP_CONNECT, OP_READ, OP_WRITE
DatagramChannel OP_READ, OP_WRITE
Pipe.SourceChannel OP_READ
Pipe.SinkChannel OP_WRITE
四. 舉例說明
1． 簡單網頁內容下載
這個例子非常簡單，類SocketChannelReader使用SocketChannel來下載特定網頁的HTML內容。
package examples.nio;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.net.InetSocketAddress;
import java.io.IOException;
public class SocketChannelReader{
private Charset charset=Charset.forName("UTF-8");//創建UTF-8字元集
private SocketChannel channel;
public void getHTMLContent(){
try{
connect();
sendRequest();
readResponse();
}catch(IOException e){
System.err.println(e.toString());
}finally{
if(channel!=null){
try{
channel.close();
}catch(IOException e){}
}
}
}
private void connect()throws IOException{//連接到CSDN
InetSocketAddress socketAddress=
new InetSocketAddress("http://www.csdn.net",80/);
channel=SocketChannel.open(socketAddress);
//使用工廠方法open創建一個channel並將它連接到指定地址上
//相當與SocketChannel.open().connect(socketAddress);調用
}
private void sendRequest()throws IOException{
channel.write(charset.encode("GET "
+"/document"
+"\r\n\r\n"));//發送GET請求到CSDN的文檔中心
//使用channel.write方法，它需要CharByte類型的參數，使用
//Charset.encode(String)方法轉換字元串。
}
private void readResponse()throws IOException{//讀取應答
ByteBuffer buffer=ByteBuffer.allocate(1024);//創建1024位元組的緩沖
while(channel.read(buffer)!=-1){
buffer.flip();//flip方法在讀緩沖區位元組操作之前調用。
System.out.println(charset.decode(buffer));
//使用Charset.decode方法將位元組轉換為字元串
buffer.clear();//清空緩沖
}
}
public static void main(String [] args){
new SocketChannelReader().getHTMLContent();
}
2． 簡單的加法伺服器和客戶機
伺服器代碼
package examples.nio;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.net.InetSocketAddress;
import java.io.IOException;
/**
* SumServer.java
*
*
* Created: Thu Nov 06 11:41:52 2003
*
* @author starchu1981
* @version 1.0
*/
public class SumServer {
private ByteBuffer _buffer=ByteBuffer.allocate(8);
private IntBuffer _intBuffer=_buffer.asIntBuffer();
private SocketChannel _clientChannel=null;
private ServerSocketChannel _serverChannel=null;
public void start(){
try{
openChannel();
waitForConnection();
}catch(IOException e){
System.err.println(e.toString());
}
}
private void openChannel()throws IOException{
_serverChannel=ServerSocketChannel.open();
_serverChannel.socket().bind(new InetSocketAddress(10000));
System.out.println("伺服器通道已經打開");
}
private void waitForConnection()throws IOException{
while(true){
_clientChannel=_serverChannel.accept();
if(_clientChannel!=null){
System.out.println("新的連接加入");
processRequest();
_clientChannel.close();
}
}
}
private void processRequest()throws IOException{
_buffer.clear();
_clientChannel.read(_buffer);
int result=_intBuffer.get(0)+_intBuffer.get(1);
_buffer.flip();
_buffer.clear();
_intBuffer.put(0,result);
_clientChannel.write(_buffer);
}
public static void main(String [] args){
new SumServer().start();
}
} // SumServer
客戶代碼
package examples.nio;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import java.nio.channels.SocketChannel;
import java.net.InetSocketAddress;
import java.io.IOException;
/**
* SumClient.java
*
*
* Created: Thu Nov 06 11:26:06 2003
*
* @author starchu1981
* @version 1.0
*/
public class SumClient {
private ByteBuffer _buffer=ByteBuffer.allocate(8);
private IntBuffer _intBuffer;
private SocketChannel _channel;
public SumClient() {
_intBuffer=_buffer.asIntBuffer();
} // SumClient constructor
public int getSum(int first,int second){
int result=0;
try{
_channel=connect();
sendSumRequest(first,second);
result=receiveResponse();
}catch(IOException e){System.err.println(e.toString());
}finally{
if(_channel!=null){
try{
_channel.close();
}catch(IOException e){}
}
}
return result;
}
private SocketChannel connect()throws IOException{
InetSocketAddress socketAddress=
new InetSocketAddress("localhost",10000);
return SocketChannel.open(socketAddress);
}
private void sendSumRequest(int first,int second)throws IOException{
_buffer.clear();
_intBuffer.put(0,first);
_intBuffer.put(1,second);
_channel.write(_buffer);
System.out.println("發送加法請求 "+first+"+"+second);
}
private int receiveResponse()throws IOException{
_buffer.clear();
_channel.read(_buffer);
return _intBuffer.get(0);
}
public static void main(String [] args){
SumClient sumClient=new SumClient();
System.out.println("加法結果為 :"+sumClient.getSum(100,324));
}
} // SumClient
3． 非阻塞的加法伺服器
首先在openChannel方法中加入語句
_serverChannel.configureBlocking(false);//設置成為非阻塞模式
重寫WaitForConnection方法的代碼如下，使用非阻塞方式
private void waitForConnection()throws IOException{
Selector acceptSelector = SelectorProvider.provider().openSelector();
/*在伺服器套接字上注冊selector並設置為接受accept方法的通知。
這就告訴Selector，套接字想要在accept操作發生時被放在ready表
上，因此，允許多元非阻塞I/O發生。*/
SelectionKey acceptKey = ssc.register(acceptSelector,
SelectionKey.OP_ACCEPT);
int keysAdded = 0;
F. 有了java.nio還有用java.io的必要嗎
有必要
Java NIO和IO之間的主要差別，我會更詳細地描述表中每部分的差異
IO NIO
面向流 面向緩沖
阻塞IO 非阻塞IO
無 選擇器
面向流與面向緩沖
Java NIO和IO之間第一個最大的區別是，IO是面向流的，NIO是面向緩沖區的。 Java IO面向流意味著每次從流中讀一個或多個位元組，直至讀取所有位元組，它們沒有被緩存在任何地方。此外，它不能前後移動流中的數據。如果需要前後移動從流中讀取的數據，需要先將它緩存到一個緩沖區。 Java NIO的緩沖導向方法略有不同。數據讀取到一個它稍後處理的緩沖區，需要時可在緩沖區中前後移動。這就增加了處理過程中的靈活性。但是，還需要檢查是否該緩沖區中包含所有您需要處理的數據。而且，需確保當更多的數據讀入緩沖區時，不要覆蓋緩沖區里尚未處理的數據。
阻塞與非阻塞IO
Java IO的各種流是阻塞的。這意味著，當一個線程調用read() 或 write()時，該線程被阻塞，直到有一些數據被讀取，或數據完全寫入。該線程在此期間不能再干任何事情了。 Java NIO的非阻塞模式，使一個線程從某通道發送請求讀取數據，但是它僅能得到目前可用的數據，如果目前沒有數據可用時，就什麼都不會獲取。而不是保持線程阻塞，所以直至數據變的可以讀取之前，該線程可以繼續做其他的事情。 非阻塞寫也是如此。一個線程請求寫入一些數據到某通道，但不需要等待它完全寫入，這個線程同時可以去做別的事情。 線程通常將非阻塞IO的空閑時間用於在其它通道上執行IO操作，所以一個單獨的線程現在可以管理多個輸入和輸出通道（channel）。
選擇器（Selectors）
Java NIO的選擇器允許一個單獨的線程來監視多個輸入通道，你可以注冊多個通道使用一個選擇器，然後使用一個單獨的線程來「選擇」通道：這些通道里已經有可以處理的輸入，或者選擇已准備寫入的通道。這種選擇機制，使得一個單獨的線程很容易來管理多個通道。
NIO和IO如何影響應用程序的設計
無論您選擇IO或NIO工具箱，可能會影響您應用程序設計的以下幾個方面：
1.對NIO或IO類的API調用。
2.數據處理。
3.用來處理數據的線程數。
API調用
當然，使用NIO的API調用時看起來與使用IO時有所不同，但這並不意外，因為並不是僅從一個InputStream逐位元組讀取，而是數據必須先讀入緩沖區再處理。
G. Java中IO與NIO的區別和使用場景
在java2以前，傳統的socket IO中，需要為每個連接創建一個線程，當並發的連接數量非常巨大時，線程所佔用的棧內存和CPU線程切換的開銷將非常巨大。java5以後使用NIO，不再需要為每個線程創建單獨的線程，可以用一個含有限數量線程的線程池，甚至一個線程來為任意數量的連接服務。由於線程數量小於連接數量，所以每個線程進行IO操作時就不能阻塞，如果阻塞的話，有些連接就得不到處理，NIO提供了這種非阻塞的能力。
NIO 設計背後的基石：反應器模式，用於事件多路分離和分派的體系結構模式。
反應器（Reactor）：用於事件多路分離和分派的體系結構模式
通常的，對一個文件描述符指定的文件或設備, 有兩種工作方式: 阻塞 與非阻塞 。所謂阻塞方式的意思是指, 當試圖對該文件描述符進行讀寫時, 如果當時沒有東西可讀,或者暫時不可寫, 程序就進入等待 狀態, 直到有東西可讀或者可寫為止。而對於非阻塞狀態, 如果沒有東西可讀, 或者不可寫, 讀寫函數馬上返回, 而不會等待 。
一種常用做法是：每建立一個Socket連接時，同時創建一個新線程對該Socket進行單獨通信（採用阻塞的方式通信）。這種方式具有很高的響應速度，並且控制起來也很簡單，在連接數較少的時候非常有效，但是如果對每一個連接都產生一個線程的無疑是對系統資源的一種浪費，如果連接數較多將會出現資源不足的情況。
另一種較高效的做法是：伺服器端保存一個Socket連接列表，然後對這個列表進行輪詢，如果發現某個Socket埠上有數據可讀時（讀就緒），則調用該socket連接的相應讀操作；如果發現某個 Socket埠上有數據可寫時（寫就緒），則調用該socket連接的相應寫操作；如果某個埠的Socket連接已經中斷，則調用相應的析構方法關閉該埠。這樣能充分利用伺服器資源，效率得到了很大提高。
傳統的阻塞式IO，每個連接必須要開一個線程來處理，並且沒處理完線程不能退出。
非阻塞式IO，由於基於反應器模式，用於事件多路分離和分派的體系結構模式，所以可以利用線程池來處理。事件來了就處理，處理完了就把線程歸還。而傳統阻塞方式不能使用線程池來處理，假設當前有10000個連接，非阻塞方式可能用1000個線程的線程池就搞定了，而傳統阻塞方式就需要開10000個來處理。如果連接數較多將會出現資源不足的情況。非阻塞的核心優勢就在這里。
為什麼會這樣，下面就對他們做進一步細致具體的分析：
首先，我們來分析傳統阻塞式IO的瓶頸在哪裡。在連接數不多的情況下，傳統IO編寫容易方便使用。但是隨著連接數的增多，問題傳統IO就不行了。因為前面說過，傳統IO處理每個連接都要消耗一個線程，而程序的效率當線程數不多時是隨著線程數的增加而增加，但是到一定的數量之後，是隨著線程數的增加而減少。這里我們得出結論，傳統阻塞式IO的瓶頸在於不能處理過多的連接。
然後，非阻塞式IO的出現的目的就是為了解決這個瓶頸。而非阻塞式IO是怎麼實現的呢？非阻塞IO處理連接的線程數和連接數沒有聯系，也就是說處理 10000個連接非阻塞IO不需要10000個線程，你可以用1000個也可以用2000個線程來處理。因為非阻塞IO處理連接是非同步的。當某個鏈接發送請求到伺服器，伺服器把這個連接請求當作一個請求"事件"，並把這個"事件"分配給相應的函數處理。我們可以把這個處理函數放到線程中去執行，執行完就把線程歸還。這樣一個線程就可以非同步的處理多個事件。而阻塞式IO的線程的大部分時間都浪費在等待請求上了。
所謂阻塞式IO流，就是指在從數據流當中讀寫數據的的時候，阻塞當前線程，直到IO流可以
重新使用為止，你也可以使用流的avaliableBytes()函數看看當前流當中有多少位元組可以讀取，這樣
就不會再阻塞了。
H. Java.nio 和 Java.io有什麼區別
nio是new io的簡稱，從jdk1.4就被引入了。其中的一些思想值得我來研究。
首先先分析下：為什麼要nio套接字？
nio的主要作用就是用來解決速度差異的。舉個例子：計算機處理的速度，和用戶按鍵盤的速度。這兩者的速度相差懸殊。如果按照經典的方法：一個用戶設定一個線程，專門等待用戶的輸入，無形中就造成了嚴重的資源浪費：每一個線程都需要珍貴的cpu時間片，由於速度差異造成了在這個交互線程中的cpu都用來等待。
nio套接字是怎麼做到的？
其實，其中的思想很簡單：輪詢。一個線程輪詢多個input；傳統的方式是：有n個客戶端就要有n個服務線程+一個監聽線程，現在採取這種凡是，可以僅僅使用1個線程來代替n個服務線程以此來解決。
具體應用例子：
在ftp的控制連接中，因為只有少量的字元命令進行傳輸，所以可以考慮利用這種輪詢的方式實現，以節省資源。
-----------------------------------------------------
Java中的阻塞和非阻塞IO包各自的優劣思考
NIO 設計背後的基石：反應器模式，用於事件多路分離和分派的體系結構模式。
反應器（Reactor）：用於事件多路分離和分派的體系結構模式
通常的，對一個文件描述符指定的文件或設備, 有兩種工作方式: 阻塞 與非阻塞 。所謂阻塞方式的意思是指, 當試圖對該文件描述符進行讀寫時, 如果當時沒有東西可讀,或者暫時不可寫, 程序就進入等待 狀態, 直到有東西可讀或者可寫為止。而對於非阻塞狀態, 如果沒有東西可讀, 或者不可寫, 讀寫函數馬上返回, 而不會等待 。
一種常用做法是：每建立一個Socket連接時，同時創建一個新線程對該Socket進行單獨通信（採用阻塞的方式通信）。這種方式具有很高的響應速度，並且控制起來也很簡單，在連接數較少的時候非常有效，但是如果對每一個連接都產生一個線程的無疑是對系統資源的一種浪費，如果連接數較多將會出現資源不足的情況。
另一種較高效的做法是：伺服器端保存一個Socket連接列表，然後對這個列表進行輪詢，如果發現某個Socket埠上有數據可讀時（讀就緒），則調用該socket連接的相應讀操作；如果發現某個 Socket埠上有數據可寫時（寫就緒），則調用該socket連接的相應寫操作；如果某個埠的Socket連接已經中斷，則調用相應的析構方法關閉該埠。這樣能充分利用伺服器資源，效率得到了很大提高。
傳統的阻塞式IO，每個連接必須要開一個線程來處理，並且沒處理完線程不能退出。
非阻塞式IO，由於基於反應器模式，用於事件多路分離和分派的體系結構模式，所以可以利用線程池來處理。事件來了就處理，處理完了就把線程歸還。而傳統阻塞方式不能使用線程池來處理，假設當前有10000個連接，非阻塞方式可能用1000個線程的線程池就搞定了，而傳統阻塞方式就需要開10000個來處理。如果連接數較多將會出現資源不足的情況。非阻塞的核心優勢就在這里。
為什麼會這樣，下面就對他們做進一步細致具體的分析：
首先，我們來分析傳統阻塞式IO的瓶頸在哪裡。在連接數不多的情況下，傳統IO編寫容易方便使用。但是隨著連接數的增多，問題傳統IO就不行了。因為前面說過，傳統IO處理每個連接都要消耗 一個線程，而程序的效率當線程數不多時是隨著線程數的增加而增加，但是到一定的數量之後，是隨著線程數的增加而減少。這里我們得出結論，傳統阻塞式IO的瓶頸在於不能處理過多的連接。
然後，非阻塞式IO的出現的目的就是為了解決這個瓶頸。而非阻塞式IO是怎麼實現的呢？非阻塞IO處理連接的線程數和連接數沒有聯系，也就是說處理10000個連接非阻塞IO不需要10000個線程，你可以用1000個也可以用2000個線程來處理。因為非阻塞IO處理連接是非同步的。當某個連接發送請求到伺服器，伺服器把這個連接請求當作一個請求"事件"，並把這個"事件"分配給相應的函數處理。我們可以把這個處理函數放到線程中去執行，執行完就把線程歸還。這樣一個線程就可以非同步的處理多個事件。而阻塞式IO的線程的大部分時間都浪費在等待請求上了。
I. Java中nio與普通io有什麼優勢
1，nio的主要作用就是用來解決速度差異的。舉個例子：計算機處理的速度，和用戶按鍵盤的速度，這兩者的速度相差懸殊。
2，如果按照經典的方法：一個用戶設定一個線程，專門等待用戶的輸入，無形中就造成了嚴重的資源浪費，每一個線程都需要珍貴的cpu時間片，由於速度差異造成了在這個交互線程中的cpu都用來等待。
3，傳統的阻塞式IO，每個連接必須要開一個線程來處理，並且沒處理完線程不能退出。
4，非阻塞式IO，由於基於反應器模式，用於事件多路分離和分派的體系結構模式，所以可以利用線程池來處理。事件來了就處理，處理完了就把線程歸還。
5，而傳統阻塞方式不能使用線程池來處理，假設當前有10000個連接，非阻塞方式可能用1000個線程的線程池就搞定了，而傳統阻塞方式就需要開10000個來處理。如果連接數較多將會出現資源不足的情況。非阻塞的核心優勢就在這里。