【Netty技術專題】「原理分析系列」Netty強大特性之ByteBuf零拷貝技術原理分析

零拷貝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的執行，節省了內存帶寬。

操作系統層面Zero-Copy

在OS層面上的Zero-copy通常指避免在用戶態(User-space) 與內核態(Kernel-space) 之間來回拷貝數據。

例如 Linux 提供的 mmap 系統調用, 它可以將一段用戶空間內存映射到內核空間, 當映射成功後, 用戶對這段內存區域的修改可以直接反映到內核空間;
內核空間對這段區域的修改也直接反映用戶空間。正因爲有這樣的映射關係, 我們就不需要在用戶態(User-space) 與內核態(Kernel-space) 之間拷貝數據, 提高了數據傳輸的效率。

Netty中的 Zero-copy 與上面我們所提到到 OS 層面上的 Zero-copy 不太一樣, Netty的 Zero-copy 完全是在用戶態(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 對象, 然後調用

public CompositeByteBuf addComponents(boolean increaseWriterIndex, ByteBuf... buffers) {
...
}

方法將 header 與 body 合併爲一個邏輯上的 ByteBuf, 即:

不過需要注意的是, 雖然看起來CompositeByteBuf是由兩個 ByteBuf 組合而成的, 不過在 CompositeByteBuf 內部, 這兩個 ByteBuf 都是單獨存在的, CompositeByteBuf 只是邏輯上是一個整體.

上面CompositeByteBuf 代碼還以一個地方值得注意的是, 我們調用addComponents(boolean increaseWriterIndex, ByteBuf... buffers) 來添加兩個 ByteBuf, 其中第一個參數是 true, 表示當添加新的 ByteBuf 時, 自動遞增 CompositeByteBuf 的 writeIndex。

除了上面直接使用 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 對象中.

通過 slice 操作實現零拷貝

slice 操作和 wrap 操作剛好相反, Unpooled.wrappedBuffer 可以將多個 ByteBuf 合併爲一個, 而 slice 操作可以將一個 ByteBuf 切片爲多個共享一個存儲區域的 ByteBuf 對象.
ByteBuf 提供了兩個 slice 操作方法:

public ByteBuf slice();
public ByteBuf slice(int index, int length);

不帶參數的 slice 方法等同於 buf.slice(buf.readerIndex(), buf.readableBytes()) 調用, 即返回 buf 中可讀部分的切片. 而 slice(int index, int length) 方法相對就比較靈活了, 我們可以設置不同的參數來獲取到 buf 的不同區域的切片.

ByteBuf byteBuf = ...
ByteBuf header = byteBuf.slice(0, 5);
ByteBuf body = byteBuf.slice(5, 10);

用 slice 方法產生 header 和 body 的過程是沒有拷貝操作的, header 和 body 對象在內部其實是共享了 byteBuf 存儲空間的不同部分而已. 即:

通過FileRegion實現零拷貝

Netty中使用FileRegion實現文件傳輸的零拷貝, 不過在底層 FileRegion 是依賴於 Java NIO FileChannel.transfer 的零拷貝功能.

首先我們從最基礎的 Java IO 開始吧. 假設我們希望實現一個文件拷貝的功能, 那麼使用傳統的方式, 我們有如下實現:

public static void copyFile(String srcFile, String destFile) throws Exception {
    byte[] temp = new byte[1024];
    FileInputStream in = new FileInputStream(srcFile);
    FileOutputStream out = new FileOutputStream(destFile);
    int length;
    while ((length = in.read(temp)) != -1) {
        out.write(temp, 0, length);
    }
    in.close();
    out.close();
}

上面是一個典型的讀寫二進制文件的代碼實現了. 不用我說, 大家肯定都知道, 上面的代碼中不斷中源文件中讀取定長數據到 temp 數組中, 然後再將 temp 中的內容寫入目的文件, 這樣的拷貝操作對於小文件倒是沒有太大的影響, 但是如果我們需要拷貝大文件時, 頻繁的內存拷貝操作就消耗大量的系統資源了，下面我們來看一下使用 Java NIO 的 FileChannel 是如何實現零拷貝的:

public static void copyFileWithFileChannel(String srcFileName, String destFileName) throws Exception {
    RandomAccessFile srcFile = new RandomAccessFile(srcFileName, "r");
    FileChannel srcFileChannel = srcFile.getChannel();
    RandomAccessFile destFile = new RandomAccessFile(destFileName, "rw");
    FileChannel destFileChannel = destFile.getChannel();
    long position = 0;
    long count = srcFileChannel.size();
    srcFileChannel.transferTo(position, count, destFileChannel);
}

可以看到, 使用了 FileChannel 後, 我們就可以直接將源文件的內容直接拷貝(transferTo) 到目的文件中, 而不需要額外借助一個臨時 buffer, 避免了不必要的內存操作，我們來看一下在 Netty 中是怎麼使用 FileRegion 來實現零拷貝傳輸一個文件的:

@Override
public void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
    RandomAccessFile raf = null;
    long length = -1;
    try {
        // 1. 通過 RandomAccessFile 打開一個文件.
        raf = new RandomAccessFile(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 封裝成一個 DefaultFileRegion
        ctx.write(new DefaultFileRegion(raf.getChannel(), 0, length));
    } else {
        // SSL enabled - cannot use zero-copy file transfer.
        ctx.write(new ChunkedFile(raf));
    }
    ctx.writeAndFlush("\n");
}

可以看到, 第一步是通過 RandomAccessFile 打開文件, 然後Netty使用DefaultFileRegion 來封裝一個 FileChannel 即:

new DefaultFileRegion(raf.getChannel(), 0, length)

java零拷貝

零拷貝的“零”是指用戶態和內核態間copy數據的次數爲零。

傳統的數據copy（文件到文件、client到server等）涉及到四次用戶態內核態切換、四次copy，四次copy中，兩次在用戶態和內核態間copy需要CPU參與、兩次在內核態與IO設備間copy爲DMA方式不需要CPU參與，零拷貝避免了用戶態和內核態間的copy、減少了兩次用戶態內核態間的切換。

java的zero copy多在網絡應用程序中使用。Java的libaries在linux和unix中支持zero copy，關鍵的api是java.nio.channel.FileChannel的transferTo()，transferFrom()方法。
可以用這兩個方法來把bytes直接從調用它的channel傳輸到另一個writable byte channel，中間不會使data經過應用程序，以便提高數據轉移的效率。

Web環境的使用零拷貝技術

許多web應用都會向用戶提供大量的靜態內容，這意味着有很多data從硬盤讀出之後，會原封不動的通過socket傳輸給用戶。這種操作看起來可能不會怎麼消耗CPU，但是實際上它是低效。

原始拷貝技術

kernal把數據從disk讀出來，然後把它傳輸給user級的application，然後application再次把同樣的內容再傳回給處於kernal級的socket，application實際上只是作爲一種低效的中間介質，用來把disk file的data傳給socket。

零拷貝技術

data每次通過user-kernel boundary，都會被copy，這會消耗CPU，並且佔用RAM的帶寬。因此你可以用一種叫做Zero-Copy的技術來去掉這些無謂的 copy。

應用程序用zero copy來請求kernel直接把disk的data傳輸給socket，而不是通過應用程序傳輸。Zero copy提高了應用程序的性能，並且減少了kernel和user模式的上下文切換。
使用kernel buffer做中介(而不是直接把data傳到user buffer中)看起來比較低效(多了一次copy)。然而實際上kernel buffer是用來提高性能的。

零拷貝的弊端問題

在進行讀操作的時候，kernel buffer起到了預讀cache的作用，當寫請求的data size比kernel buffer的size小的時候，這能夠顯著的提升性能。在進行寫操作時，kernel buffer的存在可以使得寫請求完全異步。

悲劇的是，當請求的data size遠大於kernel buffer size的時候，這個方法本身變成了性能的瓶頸。因爲data需要在disk，kernel buffer，user buffer之間拷貝很多次(每次寫滿整個buffer)。

而Zero copy正是通過消除這些多餘的data copy來提升性能。

傳統方式及涉及到的上下文切換

通過網絡把一個文件傳輸給另一個程序，在OS的內部，這個copy操作要經歷四次user mode和kernel mode之間的上下文切換，甚至連數據都被拷貝了四次，
具體步驟如下：

read() 調用導致一次從user mode到kernel mode的上下文切換。在內部調用了sys_read() 來從文件中讀取data。第一次copy由DMA (direct memory access)完成，將文件內容從disk讀出，存儲在kernel的buffer中。
然後請求的數據被copy到user buffer中，此時read()成功返回。調用的返回觸發了第二次context switch: 從kernel到user。至此，數據存儲在user的buffer中。
send() Socket call 帶來了第三次context switch，這次是從user mode到kernel mode。同時，也發生了第三次copy：把data放到了kernel adress space中。當然，這次的kernel buffer和第一步的buffer是不同的buffer。
最終 send() system call 返回了，同時也造成了第四次context switch。同時第四次copy發生，DMA egine將data從kernel buffer拷貝到protocol engine中。第四次copy是獨立而且異步的。

zero copy方式及涉及的上下文轉換

在linux 2.4及以上版本的內核中(如linux 6或centos 6以上的版本），開發者修改了socket buffer descriptor，使網卡支持 gather operation，通過kernel進一步減少數據的拷貝操作。這個方法不僅減少了context switch，還消除了和CPU有關的數據拷貝。user層面的使用方法沒有變，但是內部原理卻發生了變化：

transferTo()方法使得文件內容被copy到了kernel buffer，這一動作由DMA engine完成。沒有data被copy到socket buffer。取而代之的是socket buffer被追加了一些descriptor的信息，包括data的位置和長度。然後DMA engine直接把data從kernel buffer傳輸到protocol engine，這樣就消除了唯一的一次需要佔用CPU的拷貝操作。

Java NIO 零拷貝示例

NIO中的FileChannel擁有transferTo和transferFrom兩個方法，可直接把FileChannel中的數據拷貝到另外一個Channel，或直接把另外一個Channel中的數據拷貝到FileChannel。該接口常被用於高效的網絡/文件的數據傳輸和大文件拷貝。

在操作系統支持的情況下，通過該方法傳輸數據並不需要將源數據從內核態拷貝到用戶態，再從用戶態拷貝到目標通道的內核態，同時也避免了兩次用戶態和內核態間的上下文切換，也即使用了“零拷貝”，所以其性能一般高於Java IO中提供的方法。

通過網絡把一個文件從client傳到server：

/**
 * disk-nic零拷貝
 */
class ZerocopyServer {
    ServerSocketChannel listener = null;
    protected void mySetup() {
        InetSocketAddress listenAddr = new InetSocketAddress(9026);
        try {
            listener = ServerSocketChannel.open();
            ServerSocket ss = listener.socket();
            ss.setReuseAddress(true);
            ss.bind(listenAddr);
            System.out.println("監聽的端口:" + listenAddr.toString());
        } catch (IOException e) {
            System.out.println("端口綁定失敗 : " + listenAddr.toString() + " 端口可能已經被使用,出錯原因: " + e.getMessage());
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        ZerocopyServer dns = new ZerocopyServer();
        dns.mySetup();
        dns.readData();
    }

    private void readData() {
        ByteBuffer dst = ByteBuffer.allocate(4096);
        try {
            while (true) {
                SocketChannel conn = listener.accept();
                System.out.println("創建的連接: " + conn);
                conn.configureBlocking(true);
                int nread = 0;
                while (nread != -1) {
                    try {
                        nread = conn.read(dst);
                    } catch (IOException e) {
                        e.printStackTrace();
                        nread = -1;
                    }
                    dst.rewind();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class ZerocopyClient {
    public static void main(String[] args) throws IOException {
        ZerocopyClient sfc = new ZerocopyClient();
        sfc.testSendfile();
    }

    public void testSendfile() throws IOException {
        String host = "localhost";
        int port = 9026;
        SocketAddress sad = new InetSocketAddress(host, port);
        SocketChannel sc = SocketChannel.open();
        sc.connect(sad);
        sc.configureBlocking(true);
        String fname = "src/main/java/zerocopy/test.data";
        FileChannel fc = new FileInputStream(fname).getChannel();
        long start = System.nanoTime();
        long nsent = 0, curnset = 0;
        curnset = fc.transferTo(0, fc.size(), sc);
        System.out.println("發送的總字節數:" + curnset + " 耗時(ns):" + (System.nanoTime() - start));
        try {
            sc.close();
            fc.close();
        } catch (IOException e) {
            System.out.println(e);
        }
    }
}

文件到文件的零拷貝

/**
 * disk-disk零拷貝
 */
class ZerocopyFile {
    @SuppressWarnings("resource")
    public static void transferToDemo(String from, String to) throws IOException {
        FileChannel fromChannel = new RandomAccessFile(from, "rw").getChannel();
        FileChannel toChannel = new RandomAccessFile(to, "rw").getChannel();
        long position = 0;
        long count = fromChannel.size();
        fromChannel.transferTo(position, count, toChannel);
        fromChannel.close();
        toChannel.close();
    }
    @SuppressWarnings("resource")
    public static void transferFromDemo(String from, String to) throws IOException {
        FileChannel fromChannel = new FileInputStream(from).getChannel();
        FileChannel toChannel = new FileOutputStream(to).getChannel();
        long position = 0;
        long count = fromChannel.size();
        toChannel.transferFrom(fromChannel, position, count);
        fromChannel.close();
        toChannel.close();
    }
    public static void main(String[] args) throws IOException {
        String from = "src/main/java/zerocopy/1.data";
        String to = "src/main/java/zerocopy/2.data";
        // transferToDemo(from,to);
        transferFromDemo(from, to);
    }
}

【Netty技術專題】「原理分析系列」Netty強大特性之ByteBuf零拷貝技術原理分析

零拷貝Zero-Copy

操作系統層面Zero-Copy

Netty的零拷貝Zero-copy

通過 CompositeByteBuf 實現零拷貝

通過wrap 操作實現零拷貝

通過 slice 操作實現零拷貝

通過FileRegion實現零拷貝

java零拷貝

Web環境的使用零拷貝技術

原始拷貝技術

零拷貝技術

零拷貝的弊端問題

傳統方式及涉及到的上下文切換

zero copy方式及涉及的上下文轉換

Java NIO 零拷貝示例

通過網絡把一個文件從client傳到server：

文件到文件的零拷貝

如何熟悉一個陌生系統

裁員了！別錯過2024年大數據工程師必備的10項技能

更換容器內的源

【安裝部署】Apache SeaTunnel 和 Web快速安裝詳解

一個.NET開源的功能豐富、靈活易用的 Windows 窗口增強神器

揭祕智能寫手GPT的測試報告生成技巧

簡單郵件驗證碼html代碼模板

低代碼集成Java系列：高效構建自定義插件

【深入瞭解系統性能優化】「實戰技術專題」全方面帶你透徹探索服務優化技術方案（系統服務調優）

【Java技術專題】「攻破技術盲區」帶你攻破你很可能存在的Java技術盲點之動態性技術原理指南（反射技術專題）

【深入淺出Spring原理及實戰】「源碼調試分析」深入源碼探索Spring底層框架的的refresh方法所出現的問題和異常

【Spring專題】「技術原理」從源碼角度去深入分析關於Spring的異常處理ExceptionHandler的實現原理

【算法數據結構專題】「延時隊列算法」史上手把手教你針對層級時間輪（TimingWheel）實現延時隊列的開發實戰落地（下）

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結