https://www.cnblogs.com/94cool/p/5453033.html
此文章已同步發布在我的segmentfault專欄.
根據 Wiki 對 Zero-copy 的定義:
"Zero-copy" describes computer operations in which the CPU does not perform the task of copying data from one memory area to another. This is frequently used to save CPU cycles and memory bandwidth when transmitting a file over a network.
即所謂的Zero-copy, 就是在操作數據時, 不需要將數據 buffer 從一個內存區域拷貝到另一個內存區域. 因為少了一次內存的拷貝, 因此 CPU 的效率就得到的提升.
在 OS 層面上的Zero-copy通常指避免在用戶態(User-space)與內核態(Kernel-space)之間來回拷貝數據. 例如 Linux 提供的mmap系統調用, 它可以將一段用戶空間內存映射到內核空間, 當映射成功后, 用戶對這段內存區域的修改可以直接反映到內核空間; 同樣地, 內核空間對這段區域的修改也直接反映用戶空間. 正因為有這樣的映射關系, 我們就不需要在用戶態(User-space)與內核態(Kernel-space)之間拷貝數據, 提高了數據傳輸的效率.
而需要注意的是, Netty 中的Zero-copy與上面我們所提到到 OS 層面上的Zero-copy不太一樣, Netty的Zero-coyp完全是在用戶態(Java 層面)的, 它的Zero-copy的更多的是偏向于優化數據操作這樣的概念.
Netty 的Zero-copy體現在如下幾個個方面:
Netty 提供了CompositeByteBuf類, 它可以將多個 ByteBuf 合并為一個邏輯上的 ByteBuf, 避免了各個 ByteBuf 之間的拷貝.
通過 wrap 操作, 我們可以將 byte[] 數組、ByteBuf、ByteBuffer等包裝成一個 Netty ByteBuf 對象, 進而避免了拷貝操作.
ByteBuf 支持 slice 操作, 因此可以將 ByteBuf 分解為多個共享同一個存儲區域的 ByteBuf, 避免了內存的拷貝.
通過FileRegion包裝的FileChannel.tranferTo實現文件傳輸, 可以直接將文件緩沖區的數據發送到目標Channel, 避免了傳統通過循環 write 方式導致的內存拷貝問題.
下面我們就來簡單了解一下這幾種常見的零拷貝操作.
通過 CompositeByteBuf 實現零拷貝
假設我們有一份協議數據, 它由頭部和消息體組成, 而頭部和消息體是分別存放在兩個 ByteBuf 中的, 即:
ByteBuf header = ...
ByteBuf body = ...
我們在代碼處理中, 通常希望將 header 和 body 合并為一個 ByteBuf, 方便處理, 那么通常的做法是:
ByteBuf allBuf = Unpooled.buffer(header.readableBytes() + body.readableBytes());
allBuf.writeBytes(header);
allBuf.writeBytes(body);
可以看到, 我們將 header 和 body 都拷貝到了新的 allBuf 中了, 這無形中增加了兩次額外的數據拷貝操作了.
那么有沒有更加高效優雅的方式實現相同的目的呢? 我們來看一下CompositeByteBuf是如何實現這樣的需求的吧.
ByteBuf header = ...ByteBuf body = ...CompositeByteBuf compositeByteBuf = Unpooled.compositeBuffer();compositeByteBuf.addComponents(true, header, body);
上面代碼中, 我們定義了一個CompositeByteBuf對象, 然后調用
publicCompositeByteBufaddComponents(booleanincreaseWriterIndex, ByteBuf... buffers){...}
方法將header與body合并為一個邏輯上的 ByteBuf, 即:
CompositeBteBuf 的組合.png
不過需要注意的是, 雖然看起來 CompositeByteBuf 是由兩個 ByteBuf 組合而成的, 不過在 CompositeByteBuf 內部, 這兩個 ByteBuf 都是單獨存在的, CompositeByteBuf 只是邏輯上是一個整體.
上面CompositeByteBuf代碼還以一個地方值得注意的是, 我們調用addComponents(boolean increaseWriterIndex, ByteBuf... buffers)來添加兩個 ByteBuf, 其中第一個參數是true, 表示當添加新的 ByteBuf 時, 自動遞增 CompositeByteBuf 的writeIndex.
如果我們調用的是
compositeByteBuf.addComponents(header, body);
那么其實compositeByteBuf的writeIndex仍然是0, 因此此時我們就不可能從compositeByteBuf中讀取到數據, 這一點希望大家要特別注意.
除了上面直接使用CompositeByteBuf類外, 我們還可以使用Unpooled.wrappedBuffer方法, 它底層封裝了CompositeByteBuf操作, 因此使用起來更加方便:
ByteBuf header = ...
ByteBuf body = ...
ByteBuf allByteBuf = Unpooled.wrappedBuffer(header, body);
通過 wrap 操作實現零拷貝
例如我們有一個 byte 數組, 我們希望將它轉換為一個 ByteBuf 對象, 以便于后續的操作, 那么傳統的做法是將此 byte 數組拷貝到 ByteBuf 中, 即:
byte[] bytes = ...ByteBuf byteBuf = Unpooled.buffer();byteBuf.writeBytes(bytes);
顯然這樣的方式也是有一個額外的拷貝操作的, 我們可以使用 Unpooled 的相關方法, 包裝這個 byte 數組, 生成一個新的 ByteBuf 實例, 而不需要進行拷貝操作. 上面的代碼可以改為:
byte[] bytes = ...ByteBuf byteBuf = Unpooled.wrappedBuffer(bytes);
可以看到, 我們通過Unpooled.wrappedBuffer方法來將 bytes 包裝成為一個 UnpooledHeapByteBuf 對象, 而在包裝的過程中, 是不會有拷貝操作的. 即最后我們生成的生成的 ByteBuf 對象是和 bytes 數組共用了同一個存儲空間, 對 bytes 的修改也會反映到 ByteBuf 對象中.
Unpooled 工具類還提供了很多重載的 wrappedBuffer 方法:
publicstaticByteBufwrappedBuffer(byte[] array)publicstaticByteBufwrappedBuffer(byte[] array,intoffset,intlength)publicstaticByteBufwrappedBuffer(ByteBuffer buffer)publicstaticByteBufwrappedBuffer(ByteBuf buffer)publicstaticByteBufwrappedBuffer(byte[]... arrays)publicstaticByteBufwrappedBuffer(ByteBuf... buffers)publicstaticByteBufwrappedBuffer(ByteBuffer... buffers)publicstaticByteBufwrappedBuffer(intmaxNumComponents,byte[]... arrays)publicstaticByteBufwrappedBuffer(intmaxNumComponents, ByteBuf... buffers)publicstaticByteBufwrappedBuffer(intmaxNumComponents, ByteBuffer... buffers)
這些方法可以將一個或多個 buffer 包裝為一個 ByteBuf 對象, 從而避免了拷貝操作.
通過 slice 操作實現零拷貝
slice 操作和 wrap 操作剛好相反,Unpooled.wrappedBuffer可以將多個 ByteBuf 合并為一個, 而 slice 操作可以將一個 ByteBuf切片為多個共享一個存儲區域的 ByteBuf 對象.
ByteBuf 提供了兩個 slice 操作方法:
publicByteBufslice();publicByteBufslice(intindex,intlength);
不帶參數的slice方法等同于buf.slice(buf.readerIndex(), buf.readableBytes())調用, 即返回 buf 中可讀部分的切片. 而slice(int index, int length)方法相對就比較靈活了, 我們可以設置不同的參數來獲取到 buf 的不同區域的切片.
下面的例子展示了ByteBuf.slice方法的簡單用法:
ByteBuf byteBuf = ...ByteBuf header = byteBuf.slice(0,5);ByteBuf body = byteBuf.slice(5,10);
用slice方法產生 header 和 body 的過程是沒有拷貝操作的, header 和 body 對象在內部其實是共享了 byteBuf 存儲空間的不同部分而已. 即:
ByteBuf slice 操作.png
通過 FileRegion 實現零拷貝
Netty 中使用 FileRegion 實現文件傳輸的零拷貝, 不過在底層 FileRegion 是依賴于 Java NIOFileChannel.transfer的零拷貝功能.
首先我們從最基礎的 Java IO 開始吧. 假設我們希望實現一個文件拷貝的功能, 那么使用傳統的方式, 我們有如下實現:
publicstaticvoidcopyFile(String srcFile, String destFile)throwsException{byte[] temp =newbyte[1024];? ? FileInputStream in =newFileInputStream(srcFile);? ? FileOutputStream out =newFileOutputStream(destFile);intlength;while((length = in.read(temp)) != -1) {? ? ? ? out.write(temp,0, length);? ? }? ? in.close();? ? out.close();}
上面是一個典型的讀寫二進制文件的代碼實現了. 不用我說, 大家肯定都知道, 上面的代碼中不斷中源文件中讀取定長數據到 temp 數組中, 然后再將 temp 中的內容寫入目的文件, 這樣的拷貝操作對于小文件倒是沒有太大的影響, 但是如果我們需要拷貝大文件時, 頻繁的內存拷貝操作就消耗大量的系統資源了.
下面我們來看一下使用 Java NIO 的FileChannel是如何實現零拷貝的:
publicstaticvoidcopyFileWithFileChannel(String srcFileName, String destFileName)throwsException{? ? RandomAccessFile srcFile =newRandomAccessFile(srcFileName,"r");? ? FileChannel srcFileChannel = srcFile.getChannel();? ? RandomAccessFile destFile =newRandomAccessFile(destFileName,"rw");? ? FileChannel destFileChannel = destFile.getChannel();longposition =0;longcount = srcFileChannel.size();? ? srcFileChannel.transferTo(position, count, destFileChannel);}
可以看到, 使用了FileChannel后, 我們就可以直接將源文件的內容直接拷貝(transferTo) 到目的文件中, 而不需要額外借助一個臨時 buffer, 避免了不必要的內存操作.
有了上面的一些理論知識, 我們來看一下在 Netty 中是怎么使用FileRegion來實現零拷貝傳輸一個文件的:
@OverridepublicvoidchannelRead0(ChannelHandlerContext ctx, String msg)throwsException{? ? RandomAccessFile raf =null;longlength = -1;try{// 1. 通過 RandomAccessFile 打開一個文件.raf =newRandomAccessFile(msg,"r");? ? ? ? length = raf.length();? ? }catch(Exception e) {? ? ? ? ctx.writeAndFlush("ERR: "+ e.getClass().getSimpleName() +": "+ e.getMessage() +'\n');return;? ? }finally{if(length <0&& raf !=null) {? ? ? ? ? ? raf.close();? ? ? ? }? ? }? ? ctx.write("OK: "+ raf.length() +'\n');if(ctx.pipeline().get(SslHandler.class) ==null) {// SSL not enabled - can use zero-copy file transfer.// 2. 調用 raf.getChannel() 獲取一個 FileChannel.// 3. 將 FileChannel 封裝成一個 DefaultFileRegionctx.write(newDefaultFileRegion(raf.getChannel(),0, length));? ? }else{// SSL enabled - cannot use zero-copy file transfer.ctx.write(newChunkedFile(raf));? ? }? ? ctx.writeAndFlush("\n");}
上面的代碼是 Netty 的一個例子, 其源碼在netty/example/src/main/java/io/netty/example/file/FileServerHandler.java
可以看到,? 第一步是通過RandomAccessFile打開一個文件, 然后 Netty 使用了DefaultFileRegion來封裝一個FileChannel即:
newDefaultFileRegion(raf.getChannel(),0, length)
當有了 FileRegion 后, 我們就可以直接通過它將文件的內容直接寫入 Channel 中, 而不需要像傳統的做法: 拷貝文件內容到臨時 buffer, 然后再將 buffer 寫入 Channel. 通過這樣的零拷貝操作, 無疑對傳輸大文件很有幫助.
作者：永順
鏈接：http://www.lxweimin.com/p/1d1fa2fe1ed9
來源：簡書
簡書著作權歸作者所有，任何形式的轉載都請聯系作者獲得授權并注明出處。
