javaniois例子

1. java中IO和NIO的區別和適用場景

java.NIO包里包括三個基本的組件

lbuffer：因為NIO是基於緩沖的，所以buffer是最底層的必要類，這也是IO和NIO的根本不同，雖然stream等有buffer開頭的擴展類，但只是流的包裝類，還是從流讀到緩沖區，而NIO卻是直接讀到buffer中進行操作。

因為讀取的都是位元組，所以在操作文字時，要用charset類進行編解碼操作。

lchannel：類似於IO的stream，但是不同的是除了FileChannel，其他的channel都能以非阻塞狀態運行。FileChannel執行的是文件的操作，可以直接DMA操作內存而不依賴於CPU。其他比如socketchannel就可以在數據准備好時才進行調用。

lselector：用於分發請求到不同的channel，這樣才能確保channel不處於阻塞狀態就可以收發消息。

面向流與面向緩沖

Java NIO和IO之間第一個最大的區別是，IO是面向流的，NIO是面向緩沖區的。Java
IO面向流意味著每次從流中讀一個或多個位元組，直至讀取所有位元組，它們沒有被緩存在任何地方。此外，它不能前後移動流中的數據。如果需要前後移動從流中讀取的數據，需要先將它緩存到一個緩沖區。Java NIO的緩沖導向方法略有不同。數據讀取到一個它稍後處理的緩沖區，需要時可在緩沖區中前後移動。這就增加了處理過程中的靈活性。但是，還需要檢查是否該緩沖區中包含所有您需要處理的數據。而且，需確保當更多的數據讀入緩沖區時，不要覆蓋緩沖區里尚未處理的數據。

補充一點：NIO的buffer可以使用直接內存緩沖區，該緩沖區不在JVM中，性能會比JVM的緩沖區略好，不過會增加相應的垃圾回收的負擔，因為JVM緩沖區的性能已經足夠好，所以除非在對緩沖有特別要求的地方使用直接緩沖區，盡量姿蔽手使用JVM緩沖。

阻塞與非阻塞

Java IO是阻塞式的操作，當一個inputstream或outputstream在進行read（）或write（）操作時，是一直處於等待狀態的，直到有數據讀/寫入後才進行處理.而NIO是非阻塞式的,當進行讀寫操作時,只會返回當前已經准備好的數據,沒有就返回空,這樣當前線程就可以處理其他的事情,提高了資源的使用率.

與傳統IO的優勢

在老的IO包中，serverSocket和socket都是阻塞式的，因此一旦有大規模的並發行為，而每一個訪問都會開啟一個新線程。這時會有大規模的線程上下文切換操作（因為都在等待，所以資源全都被已有的線程吃掉了），這時無論是等待的線程還是正在處理的線程，響應率都會下降，並且會影響新的線程。

而NIO包中的serverSocket和socket就不是這樣，只要注冊到一個selector中，當有數據放入通道的時候，selector就會得知哪些channel就緒，這時就可以做響應的處理，這樣服務端只有一個線程就可以處理大部分情況（當然有些持續性操作，比如上傳下載一個大文件，用NIO的方式不會比IO好）。

通過兩個圖的比較，可以看出IO是直連的，每跡嫌個請求都給一條線程來處理，但是NIO卻是基於反應堆（selector）來處理，直到讀寫的數據准備好後，才會通知相應的線程來進行處理。一言以蔽之：「selector不會讓channel白占資源，沒事的時候給我去睡覺。」

PS:NIO基於位元組進行傳輸，在IO時要並消注意decode/encode。

更具體的信息請參閱：http://blog.csdn.net/zhansong_1987/article/details/45873861

2. java Nio讀寫為什麼是雙向

作者：美團技術團隊
鏈接：https://zhuanlan.hu.com/p/23488863
來源：知乎
著作權歸作者所有。商業轉載請聯系作者獲得授權，非商業轉載請註明出處。

NIO（Non-blocking I/O，在Java領域，也稱為New I/O），是一種同步非阻塞的I/O模型，也是I/O多路復用的基礎，已經被越來越多地應用到大型應用伺服器，成為解決高並發與大量連接、I/O處理問題的有效方式。

那麼NIO的本質是什麼樣的呢？它是怎樣與事件模型結合來解放線程、提高系統吞吐的呢？

本文會從傳統的阻塞I/O和線程池模型面臨的問題講起，然後對比幾種常見I/O模型，一步步分析NIO怎麼利用事件模型處理I/O，解決線程池瓶頸處理海量連接，包括利用面向事件的方式編寫服務端/客戶端程序。最後延展到一些高級主題，如Reactor與Proactor模型的對比、Selector的喚醒、Buffer的選擇等。

註：本文的代碼都是偽代碼，主要是為了示意，不可用於生產環境。

傳統BIO模型分析

讓我們先回憶一下傳統的伺服器端同步阻塞I/O處理（也就是BIO，Blocking I/O）的經典編程模型：

{
ExecutorService executor = Excutors.newFixedThreadPollExecutor(100);//線程池

ServerSocket serverSocket = new ServerSocket();
serverSocket.bind(8088);
while(!Thread.currentThread.isInturrupted()){//主線程死循環等待新連接到來
Socket socket = serverSocket.accept();
executor.submit(new ConnectIOnHandler(socket));//為新的連接創建新的線程
}

class ConnectIOnHandler extends Thread{
private Socket socket;
public ConnectIOnHandler(Socket socket){
this.socket = socket;
}
public void run(){
while(!Thread.currentThread.isInturrupted()&&!socket.isClosed()){死循環處理讀寫事件
String someThing = socket.read()....//讀取數據
if(someThing!=null){
......//處理數據
socket.write()....//寫數據
}

}
}
}

這是一個經典的每連接每線程的模型，之所以使用多線程，主要原因在於socket.accept()、socket.read()、socket.write()三個主要函數都是同步阻塞的，當一個連接在處理I/O的時候，系統是阻塞的，如果是單線程的話必然就掛死在那裡；但CPU是被釋放出來的，開啟多線程，就可以讓CPU去處理更多的事情。其實這也是所有使用多線程的本質：

• 利用多核。

• 當I/O阻塞系統，但CPU空閑的時候，可以利用多線程使用CPU資源。

現在的多線程一般都使用線程池，可以讓線程的創建和回收成本相對較低。在活動連接數不是特別高（小於單機1000）的情況下，這種模型是比較不錯的，可以讓每一個連接專注於自己的I/O並且編程模型簡單，也不用過多考慮系統的過載、限流等問題。線程池本身就是一個天然的漏斗，可以緩沖一些系統處理不了的連接或請求。

不過，這個模型最本質的問題在於，嚴重依賴於線程。但線程是很"貴"的資源，主要表現在：

• 線程的創建和銷毀成本很高，在Linux這樣的操作系統中，線程本質上就是一個進程。創建和銷毀都是重量級的系統函數。

• 線程本身佔用較大內存，像Java的線程棧，一般至少分配512K～1M的空間，如果系統中的線程數過千，恐怕整個JVM的內存都會被吃掉一半。

• 線程的切換成本是很高的。操作系統發生線程切換的時候，需要保留線程的上下文，然後執行系統調用。如果線程數過高，可能執行線程切換的時間甚至會大於線程執行的時間，這時候帶來的表現往往是系統load偏高、CPU sy使用率特別高（超過20%以上)，導致系統幾乎陷入不可用的狀態。

• 容易造成鋸齒狀的系統負載。因為系統負載是用活動線程數或CPU核心數，一旦線程數量高但外部網路環境不是很穩定，就很容易造成大量請求的結果同時返回，激活大量阻塞線程從而使系統負載壓力過大。

所以，當面對十萬甚至百萬級連接的時候，傳統的BIO模型是無能為力的。隨著移動端應用的興起和各種網路游戲的盛行，百萬級長連接日趨普遍，此時，必然需要一種更高效的I/O處理模型。

NIO是怎麼工作的

很多剛接觸NIO的人，第一眼看到的就是Java相對晦澀的API，比如：Channel，Selector，Socket什麼的；然後就是一坨上百行的代碼來演示NIO的服務端Demo……瞬間頭大有沒有？

我們不管這些，拋開現象看本質，先分析下NIO是怎麼工作的。

常見I/O模型對比

所有的系統I/O都分為兩個階段：等待就緒和操作。舉例來說，讀函數，分為等待系統可讀和真正的讀；同理，寫函數分為等待網卡可以寫和真正的寫。

需要說明的是等待就緒的阻塞是不使用CPU的，是在「空等」；而真正的讀寫操作的阻塞是使用CPU的，真正在"幹活"，而且這個過程非常快，屬於memory ，帶寬通常在1GB/s級別以上，可以理解為基本不耗時。

下圖是幾種常見I/O模型的對比：



密碼：380p

以上都是小編收集了大神的靈葯，喜歡的拿走吧！喜歡小編就輕輕關注一下吧！

3. 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先完成了再通知伺服器應用去啟動線程進行處理，

4. Java NIO和IO的區別

JavaNIO和IO之間的主要差別，我會更詳細地描述表中每部分的差異。
IONIO
面向流面向緩沖
阻塞IO非阻塞IO
無選擇器
面向流與面向緩沖
JavaNIO和IO之間第一個最大的區別是，IO是面向流的，NIO是面向緩沖區的。JavaIO面向流意味著每次從流中讀一個或多個位元組，直至讀取所有位元組，它們沒有被緩存在任何地方。此外，它不能前後移動流中的數據。如果需要前後移動從流中讀取的數據，需要先將它緩存到一個緩沖區。JavaNIO的緩沖導向方法略有不同。數據讀取到一個它稍後處理的緩沖區，需要時可在緩沖區中前後移動。這就增加了處理過程中的靈活性。但是，還需要檢查是否該緩沖區中包含所有您需要處理的數據。而且，需確保當更多的數據讀入緩沖區時，不要覆蓋緩沖區里尚未處理的數據。
阻塞與非阻塞IO
JavaIO的各種流是阻塞的。這意味著，當一個線程調用read()或write()時，該線程被阻塞，直到有一些數據被讀取，或數據完全寫入。該線程在此期間不能再干任何事情了。JavaNIO的非阻塞模式，使一個線程從某通道發送請求讀取數據，但是它僅能得到目前可用的數據，如果目前沒有數據可用時，就什麼都不會獲取。而不是保持線程阻塞，所以直至數據變的可以讀取之前，該線程可以繼續做其他的事情。非阻塞寫也是如此。一個線程請求寫入一些數據到某通道，但不需要等待它完全寫入，這個線程同時可以去做別的事情。線程通常將非阻塞IO的空閑時間用於在其它通道上執行IO操作，所以一個單獨的線程現在可以管理多個輸入和輸出通道（channel）。
選擇器（Selectors）
JavaNIO的選擇器允許一個單獨的線程來監視多個輸入通道，你可以注冊多個通道使用一個選擇器，然後使用一個單獨的線程來「選擇」通道：這些通道里已經有可以處理的輸入，或者選擇已准備寫入的通道。這種選擇機制，使得一個單獨的線程很容易來管理多個通道。
NIO和IO如何影響應用程序的設計
無論您選擇IO或NIO工具箱，可能會影響您應用程序設計的以下幾個方面：
1.對NIO或IO類的API調用。
2.數據處理。
3.用來處理數據的線程數。
API調用
當然，使用NIO的API調用時看起來與使用IO時有所不同，但這並不意外，因為並不是僅從一個InputStream逐位元組讀取，而是數據必須先讀入緩沖區再處理。
數據處理
使用純粹的NIO設計相較IO設計，數據處理也受到影響。
在IO設計中，我們從InputStream或Reader逐位元組讀取數據。假設你正在處理一基於行的文本數據流，例如：
Name:Anna
Age:25
Email:[email protected]
Phone:1234567890
該文本行的流可以這樣處理：
BufferedReaderreader=newBufferedReader(newInputStreamReader(input));

StringnameLine=reader.readLine();
StringageLine=reader.readLine();
StringemailLine=reader.readLine();
StringphoneLine=reader.readLine();
請注意處理狀態由程序執行多久決定。換句話說，一旦reader.readLine()方法返回，你就知道肯定文本行就已讀完，readline()阻塞直到整行讀完，這就是原因。你也知道此行包含名稱；同樣，第二個readline()調用返回的時候，你知道這行包含年齡等。正如你可以看到，該處理程序僅在有新數據讀入時運行，並知道每步的數據是什麼。一旦正在運行的線程已處理過讀入的某些數據，該線程不會再回退數據（大多如此）。下圖也說明了這條原則：
（JavaIO:從一個阻塞的流中讀數據）而一個NIO的實現會有所不同，下面是一個簡單的例子：
ByteBufferbuffer=ByteBuffer.allocate(48);

intbytesRead=inChannel.read(buffer);
注意第二行，從通道讀取位元組到ByteBuffer。當這個方法調用返回時，你不知道你所需的所有數據是否在緩沖區內。你所知道的是，該緩沖區包含一些位元組，這使得處理有點困難。
假設第一次read(buffer)調用後，讀入緩沖區的數據只有半行，例如，「Name:An」，你能處理數據嗎？顯然不能，需要等待，直到整行數據讀入緩存，在此之前，對數據的任何處理毫無意義。
所以，你怎麼知道是否該緩沖區包含足夠的數據可以處理呢？好了，你不知道。發現的方法只能查看緩沖區中的數據。其結果是，在你知道所有數據都在緩沖區里之前，你必須檢查幾次緩沖區的數據。這不僅效率低下，而且可以使程序設計方案雜亂不堪。例如：
ByteBufferbuffer=ByteBuffer.allocate(48);

intbytesRead=inChannel.read(buffer);

while(!bufferFull(bytesRead)){

bytesRead=inChannel.read(buffer);

}
bufferFull()方法必須跟蹤有多少數據讀入緩沖區，並返回真或假，這取決於緩沖區是否已滿。換句話說，如果緩沖區准備好被處理，那麼表示緩沖區滿了。
bufferFull()方法掃描緩沖區，但必須保持在bufferFull（）方法被調用之前狀態相同。如果沒有，下一個讀入緩沖區的數據可能無法讀到正確的位置。這是不可能的，但卻是需要注意的又一問題。
如果緩沖區已滿，它可以被處理。如果它不滿，並且在你的實際案例中有意義，你或許能處理其中的部分數據。但是許多情況下並非如此。下圖展示了「緩沖區數據循環就緒」：
3)用來處理數據的線程數
NIO可讓您只使用一個（或幾個）單線程管理多個通道（網路連接或文件），但付出的代價是解析數據可能會比從一個阻塞流中讀取數據更復雜。
如果需要管理同時打開的成千上萬個連接，這些連接每次只是發送少量的數據，例如聊天伺服器，實現NIO的伺服器可能是一個優勢。同樣，如果你需要維持許多打開的連接到其他計算機上，如P2P網路中，使用一個單獨的線程來管理你所有出站連接，可能是一個優勢。一個線程多個連接的設計方案如
JavaNIO:單線程管理多個連接
如果你有少量的連接使用非常高的帶寬，一次發送大量的數據，也許典型的IO伺服器實現可能非常契合。下圖說明了一個典型的IO伺服器設計：

JavaIO:一個典型的IO伺服器設計-一個連接通過一個線程處理

5. java.nio的描述

定義作為數據容器的緩沖區，並提供其他 NIO 包的概述。
NIO API 的集中抽象為：
緩沖區，它們是數據容器；
字元集及其相關解碼器 和編碼器，
它們在位元組和 Unicode字元之間進行轉換；
各種類型的通道，它們表示到能夠執行 IO 操作的
實體的連接；以及選擇器 和選擇鍵，它們與
可橋升簡選擇信道 一起定義了多路的、無阻塞的
I/O 設施。
java.nio 包定義了緩沖區類，這些類用於所有 NIO API。java.nio.charset包中定義了字元集API，java.nio.channels包中定義了信道和選擇器 API。每個子包都具有自己的服務提供程序介面(SPI) 子包，SPI 子包的內容可用於擴展平台的默認實現或構造替代實現。
緩沖敏褲區
描述
Buffer 位置，界限和容量；
清除，反轉，重笑模繞和標記/重置
ByteBuffer Get/put，壓縮，查看；分配，包裝
MappedByteBuffer 映射到文件的位元組緩沖區
CharBuffer Get/put，壓縮；分配，包裝
DoubleBuffer ' '
FloatBuffer ' '
IntBuffer ' '
LongBuffer ' '
ShortBuffer ' '
ByteOrder 位元組順序的類型安全的枚舉



6. Java中nio與普通io有什麼優勢

1，nio的主要作用就是用來解決速度差異的。舉個例子：計算機處理的速度，和用戶按鍵盤的速度，這兩者的速度相差懸殊。

2，如果按照經典的方法：一個用戶設定一個線程，專門等待用戶的輸入，無形中就造成了嚴重的資源浪費，每一個線程都需要珍貴的cpu時間片，由於速度差異造成了在這個交互線程中的cpu都用來等待。

3，傳統的阻塞式IO，每個連接必須要開一個線程來處理，並且沒處理完線程不能退出。

4，非阻塞式IO，由於基於反應器模式，用於事件多路分離和分派的體系結構模式，所以可以利用線程池來處理。事件來了就處理，處理完了就把線程歸還。

5，而傳統阻塞方式不能使用線程池來處理，假設當前有10000個連接，非阻塞方式可能用1000個線程的線程池就搞定了，而傳統阻塞方式就需要開10000個來處理。如果連接數較多將會出現資源不足的情況。非阻塞的核心優勢就在這里。

7. java nio 是什麼

nio是java New IO的簡稱，在jdk1.4里提供的新api。Sun官方標榜的特性如下：
– 為輪歲所有的原始類型提供(Buffer)緩存支持。
– 字塌桐老符集編碼解碼解決方案。
–團升 Channel：一個新的原始I/O抽象。
– 支持鎖和內存映射文件的文件訪問介面。
– 提供多路(non-bloking)非阻塞式的高伸縮性網路I/O。

8. 介紹一下Java NIO，NIO讀取文件都有哪些方法

NIO也就是New I/O,是一組擴展Java IO操作的API集， 於Java 1.4起被引入，Java 7中NIO又提供了一些新的文件系統API，叫NIO2.
NIO2提供兩種主要的文件讀取方法：
使用buffer和channel類
使胡舉吵用Path 和 File 類
NIO讀取文件有以下三種方式：
1. 舊的NIO方式，使用BufferedReader
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class WithoutNIOExample
{
public static void main(String[] args)
{
BufferedReader br = null;
String sCurrentLine = null;
try
{
br = new BufferedReader(
new FileReader("test.txt"));
while ((sCurrentLine = br.readLine()) != null)
{
System.out.println(sCurrentLine);
}
}
catch (IOException e)
{
e.printStackTrace();
}
finally
{
try
{
if (br != null)
br.close();
} catch (IOException ex)
{
ex.printStackTrace();
}
}
}
}
2. 使用buffer讀取小文件
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class ReadFileWithFileSizeBuffer
{
public static void main(String args[])
{
try
{
RandomAccessFile aFile = new RandomAccessFile(
"test.txt","r");
FileChannel inChannel = aFile.getChannel();
long fileSize = inChannel.size();
ByteBuffer buffer = ByteBuffer.allocate((int) fileSize);
inChannel.read(buffer);
buffer.rewind();
buffer.flip();
for (int i = 0; i < fileSize; i++)
{
System.out.print((char) buffer.get());
}
inChannel.close();
aFile.close();
}
catch (IOException exc)
{
System.out.println(exc);
System.exit(1);
}
}
}
3. 分塊答伍讀取大文件
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class ReadFileWithFixedSizeBuffer
{
public static void main(String[] args) throws IOException
{
RandomAccessFile aFile = new RandomAccessFile
("test.txt", "r");
FileChannel inChannel = aFile.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
while(inChannel.read(buffer) > 0)
{
buffer.flip();
for (int i = 0; i <褲侍 buffer.limit(); i++)
{
System.out.print((char) buffer.get());
}
buffer.clear(); // do something with the data and clear/compact it.
}
inChannel.close();
aFile.close();
}
}
4. 使用MappedByteBuffer讀取文件
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
public class ReadFileWithMappedByteBuffer
{
public static void main(String[] args) throws IOException
{
RandomAccessFile aFile = new RandomAccessFile
("test.txt", "r");
FileChannel inChannel = aFile.getChannel();
MappedByteBuffer buffer = inChannel.map(FileChannel.MapMode.READ_ONLY, 0, inChannel.size());
buffer.load();?
for (int i = 0; i < buffer.limit(); i++)
{
System.out.print((char) buffer.get());
}
buffer.clear(); // do something with the data and clear/compact it.
inChannel.close();
aFile.close();
}
}

9. JAVA NIO編程中，什麼叫做通道事件就緒呢

如果你將selector理解成一個不斷循環的線程你就比較容易理解事件了，假設伺服器的selector就是不斷循環去判斷每個鏈接到這里的Channel的狀態發生了如何的變化。一旦Channel有了狀態的變化，selector就發出相應的事件

10. JAVA 非阻塞通信（NIO）相比普通socket通信,非阻塞表現在哪裡本質區別是什麼

0，則侍重連，重新再來過一次唄。
1，NIO 本身是提供非阻塞式的網路訪問，使用 selector 來輪詢事件，因此用 selector 才能改進性能，一個 selector 可以用在多個 socket 通信中而不像以前傳統的一個線程一個 socket 流這么麻煩地管理它們。
2，客戶端與服務端是互不影響的，完全不相關。我們完全不需要關心對方是C++ / VB 還是 Java ，只要雙方使用的都是 TCP 協議就行了。

NIO 是在與操作系統的模塊打交道，盡量提高性能，所有的真實過程其實都是在 JVM 的 native 代碼孫陸吵與操作系統中處理了，對我們應用程序來說，使用什麼方法並悉敗沒有區別。