niojava例子

❶ 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

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

❷ 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:anna@mailserver.com
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伺服器設計-一個連接通過一個線程處理

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

以前在遠標學過nio是new io的簡稱，從jdk1.4就被引入了，可以說不是什麼新東西了。nio的主要作用就是用來解決速度差異的。舉個例子：計算機處理的速度，和用戶按鍵盤的速度。這兩者的速度相差懸殊。如果按照經典的方法：一個用戶設定一個線程，專門等待用戶的輸入，無形中就造成了嚴重的資源浪費：每一個線程都需要珍貴的cpu時間片，由於速度差異造成了在這個交互線程中的cpu都用來等待。 在以前的 Java IO 中，都是阻塞式 IO，NIO 引入了非阻塞式 IO。

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

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

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

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

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

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

❺ java nio 非阻塞讀寫具體應該怎麼操作，能否給個例子程序

packagecom.java.xiong.Net17;

importjava.io.IOException;
importjava.net.InetSocketAddress;
importjava.nio.ByteBuffer;
importjava.nio.channels.Channel;
importjava.nio.channels.SelectionKey;
importjava.nio.channels.Selector;
importjava.nio.channels.ServerSocketChannel;
importjava.nio.channels.SocketChannel;
importjava.nio.charset.Charset;

publicclassNServer{

//用於檢測所有的Channel狀態的selector
privateSelectorselector=null;
staticfinalintPORT=30000;
//定義實現編碼、解碼的字元串集對象
privateCharsetcharse=Charset.forName("GBK");

publicvoidinit()throwsIOException{
selector=Selector.open();
//通過open方法來打開一個未綁定的ServerSocketChannel是咧
ServerSocketChannelserver=ServerSocketChannel.open();
InetSocketAddressisa=newInetSocketAddress("127.0.0.1",PORT);
//將該ServerSocketChannel綁定到指定的IP地址
server.bind(isa);
//設置serverSocket已非阻塞方式工作
server.configureBlocking(false);
//將server注冊到指定的selector對象
server.register(selector,SelectionKey.OP_ACCEPT);
while(selector.select()>0){
//一次處理selector上的每個選擇的SelectionKey
for(SelectionKeysk:selector.selectedKeys()){
//從selector上已選擇的Kye集中刪除正在處理的SelectionKey
selector.selectedKeys().remove(sk);
//如果sk對應的Channel包含客戶端的連接請求
if(sk.isAcceptable()){
//調用accept方法接收連接，產生伺服器段的SocketChennal
SocketChannelsc=server.accept();
//設置採用非阻塞模式
sc.configureBlocking(false);
//將該SocketChannel注冊到selector
sc.register(selector,SelectionKey.OP_READ);
}
//如果sk對應的Channel有數據需要讀取
if(sk.isReadable()){
//獲取該SelectionKey對銀行的Channel，該Channel中有刻度的數據
SocketChannelsc=(SocketChannel)sk.channel();
//定義備注執行讀取數據源的ByteBuffer
ByteBufferbuff=ByteBuffer.allocate(1024);
Stringcontent="";
//開始讀取數據
try{
while(sc.read(buff)>0){
buff.flip();
content+=charse.decode(buff);
}
System.out.println("讀取的數據："+content);
//將sk對應的Channel設置成准備下一次讀取
sk.interestOps(SelectionKey.OP_READ);
}
//如果捕獲到該sk對銀行的Channel出現了異常，表明
//Channel對應的Client出現了問題，所以從Selector中取消
catch(IOExceptionio){
//從Selector中刪除指定的SelectionKey
sk.cancel();
if(sk.channel()!=null){
sk.channel().close();
}
}
//如果content的長度大於0,則連天信息不為空
if(content.length()>0){
//遍歷selector里注冊的所有SelectionKey
for(SelectionKeykey:selector.keys()){
//獲取該key對應的Channel
ChanneltargerChannel=key.channel();
//如果該Channel是SocketChannel對象
if(){
//將讀取到的內容寫入該Channel中
SocketChanneldest=(SocketChannel)targerChannel;
dest.write(charse.encode(content));
}
}
}
}
}
}

}

publicstaticvoidmain(String[]args)throwsIOException{
newNServer().init();
}

}

❻ java nio網上的例子都是死循環，CUP 100%，誰給我個真正能用的例子

看什麼孫衛琴啊，都是垃圾，你好好看看安裝好的JDK中的demo程序，那才是精品，其中有一個文件夾，全是nio的例子，保證運行，而且nio也不用非要用什麼socket好吧，讀文件也能用哈，只要是IO的流都可以

❼ 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;

❽ java NIO編寫伺服器和客戶端可以讀寫Object求給個例子

客戶端發送:
len+type+command+userid+":"+content+";"
例: 32 001 001 10001 : helloworld!;

其中32為len為整數 001為type為short，001為command為short,
10001為userid為八位元組long, content為變長字元串。「；」和"："分別一位元組。

type： 判斷type可知道客戶端的請求類型，如是聊天還是游戲
command： 判斷command類型可知道客戶端的請求具體命令，如聊天，表情等

所以，整個數據包頭長度為: 4+2+2+8+1+content長+1
content的長度可以算出來；
byte[] stringBytes=content.getBytes();
len= StringBytes.length();

數據包的頭部長度為: int headLen=4+2+2+8+1;
數據包中數據體的長度為: int datalen= len+1;
整個數據包的長度為： headLen+datalen;

客戶端發送時壓成 :
byte[] toSend=new byte[headLen+datalen];
分別用System.arrayCopy命令將內容考入soSend中
datalen 到toSend的前兩個位元組
type 到toSend 占兩個位元組
command
userid
":"
content.getBytes()
";"
//行了， tosend中己經有壓縮編碼好的消息了
outputStream.write(toSend);//發送到服務端
outputStream.flash();//別忘了flash
////////////// 客戶端發送完畢

服務端收取
byte[] datas=new byte[len];
inputStream.read(datas);
現在datas中己包含客戶端發過來的byte[]
//////////// 下面開始解析
1。從 datas中拿兩個位元組出來得到len
2。再拿兩個位元組出來，得到 type
3。得到command
4。得到userid
5。拿一個位元組 得到:或者；，如果沒有：只有;證明客戶端就發了個空消息
6。根據len的長度拿len個位元組，得到String str=new String(指定長度拿來的byte[]，指定編碼);
7。 解析str，丟棄； 細分str的具體內容
//////////// 解析結束

另外一種辦法，很偷懶，效率低一丁點：
全部用String 不用計算長度，最簡單， 各數據項之間用"，"分割
String toString="len,type,command,userid: targetUserid,chatContent;"
這種形式最簡單，效率會低點，但你初學可以直接用，以後再改進。
具體如下：
StringBuffer buffer =new StringBuffer();
buffer.append(len);
buffer.append(",");
buffer.append(type);
buffer.append(",");
buffer.append(command);
buffer.append(,);
buffer.append(userid);
buffer.append(":");
buffer.append(對方帳號);
buffer.append(",");
buffer.append(內容);
buffer.append(";");
String result=buffer.toString();
outputstream.write(result.getBytes("utf-8"));
flash()

///服務端收到以後，是純字元串
先按";"split得到數個消息包
再按":"得到消息體得消息頭
再按","解析具體內容

❾ 求java nio網路編程的小例子，要求客戶端一直與伺服器保持連接

import java.awt.*;
import java.awt.event.*;
import java.io.IOException;
import java.net.*;
import java.io.*;

public class chatClient extends Frame {

/**
* @param args
*/
TextField tfTxT=new TextField();
TextArea taContent=new TextArea();
Socket s=null;
DataOutputStream dos=null;
DataInputStream dis=null;
private boolean bConnected =false;

public static void main(String[] args) {
new chatClient().lunachFrame();
}

private class RecvThread implements Runnable{

public void run() {
try{
while(bConnected){
String str=dis.readUTF();
taContent.setText(taContent.getText()+str+'\n');
}
}catch(IOException e){
e.printStackTrace();
}
}

}

public void lunachFrame(){
this.setLocation(400, 300);
this.setSize(300,300);
//this.setLayout(new FlowLayout());
this.add(tfTxT,"South");
this.add(taContent,"North");
pack();
tfTxT.addActionListener(new TFListener());
this.addWindowListener(new WindowClose());
this.setVisible(true);
connect();
new Thread(new RecvThread()).start();
}

public void connect(){
try {
s= new Socket("127.0.0.1",8888);
dos =new DataOutputStream(s.getOutputStream());
dis =new DataInputStream(s.getInputStream());
System.out.println("connected!");
bConnected=true;
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

public void disconnect(){
try {
dos.close();
s.close();
} catch (Exception e) {
// TODO 自動生成 catch 塊
e.printStackTrace();
}
}

class WindowClose extends WindowAdapter{

@Override
public void windowClosing(WindowEvent e) {
// TODO 自動生成方法存根
System.exit(0);
disconnect();
}

}

private class TFListener implements ActionListener{

public void actionPerformed(ActionEvent e) {
String str=tfTxT.getText().trim();//trim去掉兩邊空格
//taContent.setText(str);
tfTxT.setText("");
try {
dos.writeUTF(str);
dos.flush();
//dos.close();

} catch (IOException e1) {
e1.printStackTrace();

}
}
}
}

======================================
import java.io.IOException;
import java.net.*;
import java.io.*;
import java.util.*;

public class ChatServer {
List<Client> clients=new ArrayList<Client>();
Client c=null;

public static void main(String[] args){
new ChatServer().start();
}

public void start(){
boolean started=false;
ServerSocket ss=null;
DataInputStream dis=null;
try{
ss=new ServerSocket(8888);
started =true;
}catch(Exception e)
{
e.printStackTrace();
}
try{
while(started){
Socket s=ss.accept();
c=new Client(s);//啟動線程,實行run()方法
System.out.println("a client connected!");
new Thread(c).start();//啟動start方法,循環.start是Thread中的方法與這上面的start無關
clients.add(c);
//dis.close();
}
} catch (Exception e) {

//e.printStackTrace();
}
finally{
try {
ss.close();
} catch (IOException e) {
// TODO 自動生成 catch 塊
e.printStackTrace();
}
}
}

class Client implements Runnable{

private Socket s;
private DataInputStream dis =null;
private boolean bConnected =false;
private DataOutputStream dos=null;

public Client(Socket s){
this.s=s;
try {
dis=new DataInputStream(s.getInputStream());
dos =new DataOutputStream(s.getOutputStream());
bConnected =true;
} catch (IOException e) {
// TODO 自動生成 catch 塊
e.printStackTrace();
}
}

public void send(String str)throws Exception{
dos.writeUTF(str);

}

public void run() {
try{
while(bConnected){
String str = dis.readUTF();
System.out.println(str);
for(int i=0;i<clients.size();i++){
c=clients.get(i);
c.send(str);
}
/*for(Iterator<Client> it=clients.iterator();it.hasNext();){
Client c=it.next();
c.send(str);
}*/
}
}catch(SocketException e){
clients.remove(this);
System.out.println("客戶下線了");
}
catch(EOFException e){
System.out.println("Client closed");
}
catch (Exception e){

//e.printStackTrace();
}
finally{
try {
if(dis !=null) dis.close();
if(dos !=null) dos.close();
if(s!=null) s.close();
} catch (Exception e1) {
// TODO 自動生成 catch 塊
//e1.printStackTrace();
}
}
}
}

}

第一個是客戶端,
第二個是server端

❿ Java NIO怎麼理解通道和非阻塞

nio引入了buffer、channel、selector等概念。
通道相當於之前的I/O流。
「通道」太抽象了。java解釋不清的東西只能看它底層是怎麼解釋的——操作系統的I/O控制，通道控制方式？
I/O設備：CPU——通道——設備控制器——I/O設備
（通道和設備控制器的關系是多對多，設備控制器和I/O設備的關系也是多對多。）
I/O過程，參考http://www.nbrkb.net/lwt/jsjsj/asm/INTR&DMA.htm：
1.CPU在執行用戶程序時遇到I/O請求，根據用戶的I/O請求生成通道程序（也可以是事先編好的）。放到內存中，並把該通道程序首地址放入CAW中。
2.CPU執行「啟動I/O」指令，啟動通道工作。
3.通道接收「啟動I/O」指令信號，從CAW（記錄下一條通道指令存放的地址）中取出通道程序首地址，並根據此地址取出通道程序的第一條指令，放入CCW（記錄正在執行的通道指令）中；同時向CPU發回答信號，通知「啟動I/O」指令完成完畢，CPU可繼續執行。
4.與此同時，通道開始執行通道程序，進行物理I/O操作。當執行完一條指令後，如果還有下一條指令則繼續執行；否則表示傳輸完成，同時自行停止，通知CPU轉去處理通道結束事件，並從CCW中得到有關通道狀態。

如此一來，主處理器只要發出一個I/O操作命令，剩下的工作完全由通道負責。I/O操作結束後，I/O通道會發出一個中斷請求，表示相應操作已完成。

通道控制方式是對數據塊進行處理的，並非位元組。

通道控制方式就是非同步I/O，參考http://blog.csdn.net/historyasamirror/article/details/5778378：
I/O分兩段：1.數據從I/O設備到內核緩沖區。2.數據從內核緩沖區到應用緩沖區

I/O類型：
1.非同步I/O不會產生阻塞，程序不會等待I/O完成，繼續執行代碼，等I/O完成了再執行一個什麼回調函數，代碼執行效率高。很容易聯想到ajax。這個一般用於I/O操作不影響之後的代碼執行。
2.阻塞I/O，程序發起I/O操作後，進程阻塞，CPU轉而執行其他進程，I/O的兩個步驟完成後，向CPU發送中斷信號，進程就緒，等待執行。
3.非阻塞I/O並非都不阻塞，其實是第一步不阻塞，第二部阻塞。程序發起I/O操作後，進程一直檢查第一步是否完成，CPU一直在循環詢問，完成後，進程阻塞直到完成第二步。明白了！這個是「站著茅坑不拉屎」，CPU利用率最低的。邏輯和操作系統的程序直接控制方式一樣。
阻塞不阻塞描述的是發生I/O時當前線程的狀態。
以上是操作系統的I/O，那麼java的nio又是怎樣的呢？
個人覺得是模仿了通道控制方式。
先看看nio的示例代碼：
服務端TestReadServer.java

import java.io.IOException; import java.net.InetSocketAddress; import java.net.ServerSocket; 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; public class TestReadServer { /*標識數字*/ private int flag = 0; /*緩沖區大小*/ private int BLOCK = 1024*1024*10; /*接受數據緩沖區*/ private ByteBuffer sendbuffer = ByteBuffer.allocate(BLOCK); /*發送數據緩沖區*/ private ByteBuffer receivebuffer = ByteBuffer.allocate(BLOCK); private Selector selector; public TestReadServer(int port) throws IOException { // 打開伺服器套接字通道 ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); // 伺服器配置為非阻塞 serverSocketChannel.configureBlocking(false); // 檢索與此通道關聯的伺服器套接字 ServerSocket serverSocket = serverSocketChannel.socket(); // 進行服務的綁定 serverSocket.bind(new InetSocketAddress(port)); // 通過open()方法找到Selector selector = Selector.open(); // 注冊到selector，等待連接 serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); System.out.println("Server Start----"+port+":"); } // 監聽 private void listen() throws IOException { while (true) { // 選擇一組鍵，並且相應的通道已經打開 selector.select(); // 返回此選擇器的已選擇鍵集。 Set<SelectionKey> selectionKeys = selector.selectedKeys(); Iterator<SelectionKey> iterator = selectionKeys.iterator(); while (iterator.hasNext()) { SelectionKey selectionKey = iterator.next(); iterator.remove(); handleKey(selectionKey); } } } // 處理請求 private void handleKey(SelectionKey selectionKey) throws IOException { // 接受請求 ServerSocketChannel server = null; SocketChannel client = null; String receiveText; String sendText; int count=0; // 測試此鍵的通道是否已准備好接受新的套接字連接。 if (selectionKey.isAcceptable()) { // 返回為之創建此鍵的通道。 server = (ServerSocketChannel) selectionKey.channel(); // 接受到此通道套接字的連接。 // 此方法返回的套接字通道（如果有）將處於阻塞模式。 client = server.accept(); // 配置為非阻塞 client.configureBlocking(false); // 注冊到selector，等待連接 client.register(selector, SelectionKey.OP_READ); } else if (selectionKey.isReadable()) { // 返回為之創建此鍵的通道。 client = (SocketChannel) selectionKey.channel(); //將緩沖區清空以備下次讀取 receivebuffer.clear(); //讀取伺服器發送來的數據到緩沖區中 System.out.println(System.currentTimeMillis()); count = client.read(receivebuffer); System.out.println(System.currentTimeMillis() + "~"+count); } } /** * @param args * @throws IOException */ public static void main(String[] args) throws IOException { // TODO Auto-generated method stub int port = 1234; TestReadServer server = new TestReadServer(port); server.listen(); } }客戶端TestReadClient.javaimport java.io.BufferedInputStream; import java.io.File; import java.io.FileInputStream; 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; public class TestReadClient { /*標識數字*/ private static int flag = 0; /*緩沖區大小*/ private static int BLOCK = 1024*1024*10; /*接受數據緩沖區*/ private static ByteBuffer sendbuffer = ByteBuffer.allocate(BLOCK); /*發送數據緩沖區*/ private static ByteBuffer receivebuffer = ByteBuffer.allocate(BLOCK); /*伺服器端地址*/ private final static InetSocketAddress SERVER_ADDRESS = new InetSocketAddress( "localhost", 1234); public static void main(String[] args) throws IOException { // TODO Auto-generated method stub // 打開socket通道 SocketChannel socketChannel = SocketChannel.open(); // 設置為非阻塞方式 socketChannel.configureBlocking(false); // 打開選擇器 Selector selector = Selector.open(); // 注冊連接服務端socket動作 socketChannel.register(selector, SelectionKey.OP_CONNECT); // 連接 socketChannel.connect(SERVER_ADDRESS); // 分配緩沖區大小內存 Set<SelectionKey> selectionKeys; Iterator<SelectionKey> iterator; SelectionKey selectionKey; SocketChannel client; String receiveText; String sendText; int count=0; while (true) { //選擇一組鍵，其相應的通道已為 I/O 操作準備就緒。 //此方法執行處於阻塞模式的選擇操作。 selector.select(); //返回此選擇器的已選擇鍵集。 selectionKeys = selector.selectedKeys(); //System.out.println(selectionKeys.size()); iterator = selectionKeys.iterator(); while (iterator.hasNext()) { selectionKey = iterator.next(); if (selectionKey.isConnectable()) { System.out.println("client connect"); client = (SocketChannel) selectionKey.channel(); // 判斷此通道上是否正在進行連接操作。 // 完成套接字通道的連接過程。 if (client.isConnectionPending()) { client.finishConnect(); System.out.println("完成連接!"); sendbuffer.clear(); BufferedInputStream br = new BufferedInputStream(new FileInputStream(new File("D:\BigData.zip"))); byte[] b = new byte[BLOCK]; br.read(b); sendbuffer.put(b); sendbuffer.flip(); System.out.println(System.currentTimeMillis()); client.write(sendbuffer); System.out.println(System.currentTimeMillis()); } client.register(selector, SelectionKey.OP_READ); } else if (selectionKey.isReadable()) { client = (SocketChannel) selectionKey.channel(); //將緩沖區清空以備下次讀取 receivebuffer.clear(); //讀取伺服器發送來的數據到緩沖區中 count=client.read(receivebuffer); if(count>0){ receiveText = new String( receivebuffer.array(),0,count); System.out.println("客戶端接受伺服器端數據--:"+receiveText); client.register(selector, SelectionKey.OP_WRITE); } } } selectionKeys.clear(); } } }例子是TestReadClient向TestReadServer發送一個本地文件。TestReadServer收到後每次列印讀取到的位元組數。

如何體現非同步I/O？
看看TestReadClient中的：

if (selectionKey.isConnectable()) { System.out.println("client connect"); client = (SocketChannel) selectionKey.channel(); // 判斷此通道上是否正在進行連接操作。 // 完成套接字通道的連接過程。 if (client.isConnectionPending()) { client.finishConnect();如果沒有client.finishConnect();這句等待完成socket連接，可能會報異常：java.nio.channels.NotYetConnectedException

非同步的才不會管你有沒有連接成功，都會執行下面的代碼。這里需要人為的干預。
如果要證明是java的nio單獨使用非阻塞I/O，真沒辦法！！！阻塞非阻塞要查看進程。。。
不過還有種說法，叫非同步非阻塞。上面那段，是用非同步方式創建連接，進程當然沒有被阻塞。使用了finishConnect()這是人為將程序中止，等待連接創建完成（是模仿阻塞將當前進程阻塞掉，還是模仿非阻塞不斷輪詢訪問，不重要了反正是程序卡住沒往下執行）。
所以，創建連接的過程用非同步非阻塞I/O可以解釋的通。那read/write的過程呢？
根據上面例子的列印結果，可以知道這個過程是同步的，沒執行完是不會執行下面的代碼的。至於底下是使用阻塞I/O還是非阻塞I/O，對於應用級程序來說不重要了。
阻塞還是非阻塞，對於正常的開發（創立連接，從連接中讀寫數據）並沒有多少的提升，操作過程都類似。
那NIO憑什麼成為高性能架構的基礎，比起IO，性能優越在哪裡，接著猜。。。
java nio有意模仿操作系統的通道控制方式，那他的底層是不是就是直接使用操作系統的通道？
通道中的數據是以塊為單位的，之前的流是以位元組為單位的，同樣的數據流操作外設的次數較多。代碼中channel都是針對ByteBuffer對象進行read/write的，而ByteBuffer又是ByteBuffer.allocate(BLOCK);這樣創建的，是一個連續的塊空間。
那ByteBuffer是不是也是模擬操作系統的緩存？
緩存在io也有，如BufferedInputStream。CPU和外設的速度差很多，緩存為了提高CPU使用率，等外設將數據讀入緩存後，CPU再統一操作，不用外設讀一次，CPU操作一次，CPU的效率會被拉下來。。。