Java NIO 操作

jopen 8年前發布 | 16K 次閱讀 Java開發

本文參考了http://www.iteye.com/magazines/132-Java-NIO

Java NIO 由以下幾個核心部分組成：

1 Channels

2 Buffers

3 Selectors

Channel 和 Buffer

基本上，所有的 IO 在NIO 中都從一個Channel 開始。Channel 有點象流。數據可以從Channel讀到Buffer中，也可以從Buffer 寫到Channel中。這里有個圖示：

Channel和Buffer有好幾種類型。下面是JAVA NIO中的一些主要Channel的實現：

4 FileChannel

5 DatagramChannel

6 SocketChannel

7 ServerSocketChannel

以下是Java NIO里關鍵的Buffer實現：

8 ByteBuffer

9 CharBuffer

10 DoubleBuffer

11 FloatBuffer

12 IntBuffer

13 LongBuffer

14 ShortBuffer

這些Buffer覆蓋了你能通過IO發送的基本數據類型：byte, short, int, long, float, double 和 char。

Selector

Selector允許單線程處理多個 Channel。如果你的應用打開了多個連接（通道），但每個連接的流量都很低，使用Selector就會很方便。例如，在一個聊天服務器中。

這是在一個單線程中使用一個Selector處理3個Channel的圖示：

要使用Selector，得向Selector注冊Channel，然后調用它的select()方法。這個方法會一直阻塞到某個注冊的通道有事件就緒。一旦這個方法返回，線程就可以處理這些事件，事件的例子有如新連接進來，數據接收等。

Java NIO的通道類似流，但又有些不同：

15 既可以從通道中讀取數據，又可以寫數據到通道。但流的讀寫通常是單向的。

16 通道可以異步地讀寫。

17 通道中的數據總是要先讀到一個Buffer，或者總是要從一個Buffer中寫入

Java NIO中的Buffer用于和NIO通道進行交互。如你所知，數據是從通道讀入緩沖區，從緩沖區寫入到通道中的。

Buffer的基本用法

使用Buffer讀寫數據一般遵循以下四個步驟：

18 寫入數據到Buffer

19 調用flip()方法

20 從Buffer中讀取數據

21 調用clear()方法或者compact()方法

當向buffer寫入數據時，buffer會記錄下寫了多少數據。一旦要讀取數據，需要通過flip()方法將Buffer從寫模式切換到讀模式。在讀模式下，可以讀取之前寫入到buffer的所有數據。

一旦讀完了所有的數據，就需要清空緩沖區，讓它可以再次被寫入。有兩種方式能清空緩沖區：調用clear()或compact()方法。clear()方法會清空整個緩沖區。compact()方法只會清除已經讀過的數據。任何未讀的數據都被移到緩沖區的起始處，新寫入的數據將放到緩沖區未讀數據的后面。

afile = new RandomAccessFile("e:/haha.txt","rw");//創建從中讀取和向其中寫入（可選）的隨機訪問文件流，該文件具有指定名稱
FileChannel channel = afile.getChannel();//得到當前文件的通道
ByteBuffer buffer = ByteBuffer.allocate(48);//設置讀取和寫入的緩沖區的大小
int byteRead = channel.read(buffer);//將數據讀入到緩沖區
while (byteRead != -1) {
buffer.flip();//調用flip()方法
while (buffer.hasRemaining()) {
System.out.print((char)buffer.get());//讀入數據
}
buffer.clear();//清空緩存，便于下次寫入
byteRead = channel.read(buffer);
}
afile.close();

Buffer的capacity,position和limit

緩沖區本質上是一塊可以寫入數據，然后可以從中讀取數據的內存。這塊內存被包裝成NIO Buffer對象，并提供了一組方法，用來方便的訪問該塊內存。

為了理解Buffer的工作原理，需要熟悉它的三個屬性：

22 capacity

23 position

24 limit

position和limit的含義取決于Buffer處在讀模式還是寫模式。不管Buffer處在什么模式，capacity的含義總是一樣的。

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）

Buffer的分配

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

ByteBuffer buf = ByteBuffer.allocate(48);

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

CharBuffer buf = CharBuffer.allocate(1024);

向Buffer中寫數據

寫數據到Buffer有兩種方式：

25 從Channel寫到Buffer。

26 通過Buffer的put()方法寫到Buffer里。

從Channel寫到Buffer的例子

int bytesRead = inChannel.read(buf);

通過put方法寫Buffer的例子：

buf.put(127);

flip()方法

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

從Buffer中讀取數據

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

27 從Buffer讀取數據到Channel。

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

從Buffer讀取數據到Channel的例子：

int bytesWritten = inChannel.write(buf);

使用get()方法從Buffer中讀取數據的例子

byte aByte = buf.get();

clear()與compact()方法

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

mark()與reset()方法

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

equals()與compareTo()方法

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

equals()

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

29 有相同的類型（byte、char、int等）。

30 Buffer中剩余的byte、char等的個數相等。

31 Buffer中所有剩余的byte、char等都相同。

如你所見，equals只是比較Buffer的一部分，不是每一個在它里面的元素都比較。實際上，它只比較Buffer中的剩余元素。

compareTo()方法

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

32 第一個不相等的元素小于另一個Buffer中對應的元素。

33 所有元素都相等，但第一個Buffer比另一個先耗盡(第一個Buffer的元素個數比另一個少)。

Java NIO開始支持scatter/gather，scatter/gather用于描述從Channel（譯者注：Channel在中文經常翻譯為通道）中讀取或者寫入到Channel的操作。
分散（scatter）從Channel中讀取是指在讀操作時將讀取的數據寫入多個buffer中。因此，Channel將從Channel中讀取的數據“分散（scatter）”到多個Buffer中。
聚集（gather）寫入Channel是指在寫操作時將多個buffer的數據寫入同一個Channel，因此，Channel 將多個Buffer中的數據“聚集（gather）”后發送到Channel。

scatter / gather經常用于需要將傳輸的數據分開處理的場合，例如傳輸一個由消息頭和消息體組成的消息，你可能會將消息體和消息頭分散到不同的buffer中，這樣你可以方便的處理消息頭和消息體。

Scattering Reads
Scattering Reads是指數據從一個channel讀取到多個buffer中。如下圖描述：

代碼示例如下：

ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body   = ByteBuffer.allocate(1024);
 ByteBuffer[] bufferArray = { header, body };
 channel.read(bufferArray);

注意buffer首先被插入到數組，然后再將數組作為channel.read() 的輸入參數。read()方法按照buffer在數組中的順序將從channel中讀取的數據寫入到buffer，當一個buffer被寫滿后，channel緊接著向另一個buffer中寫。

Scattering Reads在移動下一個buffer前，必須填滿當前的buffer，這也意味著它不適用于動態消息(譯者注：消息大小不固定)。換句話說，如果存在消息頭和消息體，消息頭必須完成填充（例如 128byte），Scattering Reads才能正常工作。

Gathering Writes

Gathering Writes是指數據從多個buffer寫入到同一個channel。如下圖描述：

代碼示例如下：

ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body   = ByteBuffer.allocate(1024);

//write data into buffers

ByteBuffer[] bufferArray = { header, body };

channel.write(bufferArray);

buffers數組是write()方法的入參，write()方法會按照buffer在數組中的順序，將數據寫入到channel，注意只有position和limit之間的數據才會被寫入。因此，如果一個buffer的容量為128byte，但是僅僅包含58byte的數據，那么這58byte的數據將被寫入到channel中。因此與Scattering Reads相反，Gathering Writes能較好的處理動態消息。

在Java NIO中，如果兩個通道中有一個是FileChannel，那你可以直接將數據從一個channel（譯者注：channel中文常譯作通道）傳輸到另外一個channel。

transferFrom()

FileChannel的transferFrom()方法可以將數據從源通道傳輸到FileChannel中（譯者注：這個方法在JDK文檔中的解釋為將字節從給定的可讀取字節通道傳輸到此通道的文件中）。下面是一個簡單的例子：

RandomAccessFile file1 = new RandomAccessFile("e:/haha.txt","rw");//創建從中讀取和向其中寫入（可選）的隨機訪問文件流
RandomAccessFile file2 = new RandomAccessFile("e:/hehe.txt","rw");
FileChannel channel1 = file1.getChannel();//得到當前文件的通道
FileChannel channel2 = file2.getChannel();
int count = (int) channel2.size();//得到channel2通道的大小
channel1.transferFrom(channel2, 0, count);//將channel2通道的數據合并到channel1通道中
ByteBuffer buffer = ByteBuffer.allocate(48);//設置讀取和寫入的緩沖區的大小
int byteRead = channel1.read(buffer);//將數據讀入到緩沖區
while (byteRead != -1) {
buffer.flip();//調用flip()方法
while (buffer.hasRemaining()) {
System.out.print((char)buffer.get());//讀入數據
}
buffer.clear();//清空緩存，便于下次寫入
byteRead = channel1.read(buffer);
}
file1.close();

方法的輸入參數position表示從position處開始向目標文件寫入數據，count表示最多傳輸的字節數。如果源通道的剩余空間小于 count 個字節，則所傳輸的字節數要小于請求的字節數。
此外要注意，在SoketChannel的實現中，SocketChannel只會傳輸此刻準備好的數據（可能不足count字節）。因此，SocketChannel可能不會將請求的所有數據(count個字節)全部傳輸到FileChannel中。

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

為什么使用Selector?

僅用單個線程來處理多個Channels的好處是，只需要更少的線程來處理通道。事實上，可以只用一個線程處理所有的通道。對于操作系統來說，線程之間上下文切換的開銷很大，而且每個線程都要占用系統的一些資源（如內存）。因此，使用的線程越少越好。

Selector的創建

通過調用Selector.open()方法創建一個Selector，如下：

Selector selector = Selector.open();

向Selector注冊通道

為了將Channel和Selector配合使用，必須將channel注冊到selector上。通過SelectableChannel.register()方法來實現，如下：

channel.configureBlocking(false);

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

與Selector一起使用時，Channel必須處于非阻塞模式下。這意味著不能將FileChannel與Selector一起使用，因為FileChannel不能切換到非阻塞模式。而套接字通道都可以。

Channel + Selector

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

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

通過Selector選擇通道

一旦向Selector注冊了一或多個通道，就可以調用幾個重載的select()方法。這些方法返回你所感興趣的事件（如連接、接受、讀或寫）已經準備就緒的那些通道。換句話說，如果你對“讀就緒”的通道感興趣，select()方法會返回讀事件已經就緒的那些通道。

下面是select()方法：

34 int select()

35 int select(long timeout)

36 int selectNow()

select()阻塞到至少有一個通道在你注冊的事件上就緒了。

select(long timeout)和select()一樣，除了最長會阻塞timeout毫秒(參數)。

selectNow()不會阻塞，不管什么通道就緒都立刻返回（譯者注：此方法執行非阻塞的選擇操作。如果自從前一次選擇操作后，沒有通道變成可選擇的，則此方法直接返回零。）。

select()方法返回的int值表示有多少通道已經就緒。亦即，自上次調用select()方法后有多少通道變成就緒狀態。如果調用select()方法，因為有一個通道變成就緒狀態，返回了1，若再次調用select()方法，如果另一個通道就緒了，它會再次返回1。如果對第一個就緒的channel沒有做任何操作，現在就有兩個就緒的通道，但在每次select()方法調用之間，只有一個通道就緒了。

selectedKeys()

一旦調用了select()方法，并且返回值表明有一個或更多個通道就緒了，然后可以通過調用selector的selectedKeys()方法，訪問“已選擇鍵集（selected key set）”中的就緒通道。如下所示：

將已定義的字符串數組寫入文件中：

String str[] =new String[]{"aaa","bbb","ccc"};
FileOutputStream fos = new FileOutputStream(new File("e:/hehe.txt"));
FileChannel fc = fos.getChannel();
ByteBuffer buf = ByteBuffer.allocate(1024);
for (int i = 0; i < str.length; i++) {
buf.put(str[i].getBytes());
}
buf.flip();//編程寫入模式
fc.write(buf);
fc.close();

復制文件到新文件

String srcFile = "e:/get.mp3";//源文件的路徑
String desFile = "e:/bebe.mp3";//新文件的路徑
fis = new FileInputStream(new File(srcFile));//得到文件流
FileOutputStream fos = new FileOutputStream(new File(desFile));
FileChannel inChannel = fis.getChannel();//得到讀文件的通道
FileChannel outChannel = fos.getChannel();//寫文件的通道
ByteBuffer buf = ByteBuffer.allocate(1024);//定義大小是1024的緩沖區
while (true) {
buf.clear();// clear方法重設緩沖區，使它可以接受讀入的數據
int flag = inChannel.read(buf);
if (flag == -1) {// clear方法重設緩沖區，使它可以接受讀入的數據
break;
}
buf.flip();// flip方法讓緩沖區可以將新讀入的數據寫入另一個通道
outChannel.write(buf);
}

將數據從輸入通道拷貝到輸出通道的過程

while (true) {
buffer.clear();
int r = fcin.read( buffer );
if (r==-1) {
break;
}
buffer.flip();
fcout.write( buffer );
}

關于緩沖區切片的：

FloatBuffer fb = FloatBuffer.allocate(10);//創建一個大小為10的FloatBuffer緩沖區
//設置為寫模式，將數據寫入緩沖區
fb.clear();
for (int i = 0; i < fb.capacity(); i++) {
fb.put(i);
}
//轉換為讀模式
fb.flip();
//如果當前的position和capacity之間還有數據
while (fb.hasRemaining()) {
System.out.print(fb.get()+",");
}
System.out.println();
//將FloatBuffer緩沖區進行切片
fb.position(3);//切片的起始位置
fb.limit(7);//切片的結束位置
FloatBuffer newBuf = fb.slice();//進行切片，切片的緩沖區newBuf和原來的FloatBuffer緩沖區共享切片之間的數據
for (int i = 0; i < newBuf.capacity(); i++) {
float j = newBuf.get(i);//更改切片的數據
j = j*10;
newBuf.put(i,j);
}
//重新設置fb的位置
fb.position(0);
fb.limit(fb.capacity());
while (fb.hasRemaining()) {
System.out.print(fb.get()+",");
}

利用nio寫入字符串到文件

String s = "aaaaaaaabbbbbbbcccccc";
File file = new File("e:/haha.txt");
FileOutputStream fos = new FileOutputStream(file);
FileChannel fc = fos.getChannel();
ByteBuffer buf = ByteBuffer.allocate(1024);
buf.put(s.getBytes());
buf.flip();
fc.write(buf);
buf.clear();
fc.close();

源碼下載

來自： http://blog.csdn.net//mockingbirds/article/details/44813529

本文由用戶 jopen 自行上傳分享，僅供網友學習交流。所有權歸原作者，若您的權利被侵害，請聯系管理員。

轉載本站原創文章，請注明出處，并保留原始鏈接、圖片水印。

本站是一個以用戶分享為主的開源技術平臺，歡迎各類分享！

本文地址：http://www.baiduhome.net/lib/view/open1453108513886.html

Java開發