当前位置： 移动技术网 > IT编程>开发语言>Java > Netty基础系列(5) --零拷贝彻底分析

Netty基础系列(5) --零拷贝彻底分析

2019年08月19日  | 移动技术网IT编程  | 我要评论

前言

上一节（）当中我们从jvm堆内存的视角解释了一波零拷贝原理，但是仅仅这样还是不够的。

为了彻底搞懂零拷贝，我们趁热打铁，接着上一节来继续讲解零拷贝的底层原理。

感受一下nio的速度

之前的章节中我们说过，nio并不能解决网络传输的速度。但是为什么很多人却说nio的速度比传统io快呢？

没错，zero copy。我们先抛出一个案例，然后根据案例来讲解底层原理。

首先，我们实现一个io的服务端接受数据，然后分别用传统io传输方式和nio传输方式来直观对比传输相同大小的文件所耗费的时间。

服务端代码如下：

public class oldioserver {

    public static void main(string[] args) throws exception {
        serversocket serversocket = new serversocket(8899);

        while (true) {
            socket socket = serversocket.accept();
            datainputstream datainputstream = new datainputstream(socket.getinputstream());

            try {
                byte[] bytearray = new byte[4096];

                while (true) {
                    int readcount = datainputstream.read(bytearray, 0, bytearray.length);

                    if (-1 == readcount) {
                        break;
                    }
                }
            } catch (exception ex) {
                ex.printstacktrace();
            }
        }
    }
}

这个是最普通的socket编程的服务端，没什么好多说的。就是绑定本地的8899端口，死循环不断接受数据。

传统io传输

public class oldioclient {

    public static void main(string[] args) throws exception {
        socket socket = new socket("localhost", 8899);

        string filename = "c:\\users\\administrator\\desktop\\test.zip";  //大小两百m的文件
        inputstream inputstream = new fileinputstream(filename);

        dataoutputstream dataoutputstream = new dataoutputstream(socket.getoutputstream());

        byte[] buffer = new byte[4096];
        long readcount;
        long total = 0;

        long starttime = system.currenttimemillis();

        while ((readcount = inputstream.read(buffer)) >= 0) {
            total += readcount;
            dataoutputstream.write(buffer);
        }

        system.out.println("发送总字节数： " + total + ", 耗时： " + (system.currenttimemillis() - starttime));

        dataoutputstream.close();
        socket.close();
        inputstream.close();
    }
}

客户端向服务端发送一个119m大小的文件。计算一下耗时用了多久

由于我的笔记本性能太渣，大概平均每次消耗的时间大概是 500ms左右。值得注意的是，我们客户端和服务端分配的缓存大小都是4096个字节。如果将这个字节分配的更小一点，那么所耗时间将会更多。因为上述传统的io实际表现并不是我们想象的那样直接将文件读到内存，然后发送。

实际情况是什么样的呢？我们在后续分析。

nio传输

public class newioclient {

    public static void main(string[] args) throws exception {
        socketchannel socketchannel = socketchannel.open();
        socketchannel.connect(new inetsocketaddress("localhost", 8899));
        socketchannel.configureblocking(true);

        string filename = "c:\\users\\administrator\\desktop\\test.zip"; //大小200m的文件

        filechannel filechannel = new fileinputstream(filename).getchannel();

        long starttime = system.currenttimemillis();

        long transfercount = filechannel.transferto(0, filechannel.size(), socketchannel); //1

        system.out.println("发送总字节数：" + transfercount + "，耗时： " + (system.currenttimemillis() - starttime));

        filechannel.close();
    }
}

nio编程不熟的同学没关系，后面会有一篇专门的章节来讲。

这里我们来关注一下注释1关于filechannel的transferto方法。（方法的doc文档很长。我删除了很多，只看重点）

    /**
     * transfers bytes from this channel's file to the given writable byte
     * channel.
     *
     * <p> this method is potentially much more efficient than a simple loop
     * that reads from this channel and writes to the target channel.  many
     * operating systems can transfer bytes directly from the filesystem cache
     * to the target channel without actually copying them.  </p>
     */
    public abstract long transferto(long position, long count,
                                    writablebytechannel target)
        throws ioexception;

翻译一下：

将文件channel的数据写到指定的channel

这个方法可能比简单的将数据从一个channel循环读到另一个channel更有效，
许多操作系统可以直接从文件系统缓存传输字节到目标通道，**而不实际复制它们**。

意思是我们调用filechannel的transferto方法就实现了零拷贝（想实现零拷贝并不止这一种方法，有更优雅的方法，这里只是作为一个演示）。当然也要看你操作系统支不支持底层zero copy。因为这部分工作其实是操作系统来完成的。

我的电脑平均执行下来大概在200ms左右。比传统io快了300ms。

底层原理

大家也可以用自己的电脑运行一下上述代码，看看nio传输一个文件比io传输一个文件快多少。

在上诉代码中，楼主这里指定的缓存只有4096个字节，而传送的文件大小有125581592个字节。

在前面我们分析过，对于传统的io而言，读取的缓存满了以后会有两次零拷贝过程。那么换算下来传输这个文件大概在内存中进行了6w多次无意义的内存拷贝，这6w多次拷贝在我的笔记本上大概所耗费的时间就是300ms左右。这就是导致nio比传统io快的更本原因。

传统io底层时序图

由上图我们可以看到。当我们想将磁盘中的数据通过网络发送的时候，

  1. 底层调用的了sendfile()方法，然后切换用户态（user space）->内核态（kemel space）。
  2. 从本地磁盘获取数据。获取的数据存储在内核态的内存空间内。
  3. 将数据复制到用户态内存空间里。
  4. 切换内核态->用户态。
  5. 用户操作数据，这里就是我们编写的java代码的具体操作。
  6. 调用操作系统的write()方法，将数据复制到内核态的socket buffer中。
  7. 切换用户态->内核态。
  8. 发送数据。
  9. 发送完毕以后，切换内核态->用户态。继续执行我们编写的java代码。

由上图可以看出。传统的io发送一次数据，进行了两次“无意义”的内存拷贝。虽然内存拷贝对于整个io来说耗时是可以忽略不计的。但是操作达到一定次数以后，就像我们上面案例的代码。就会由量变引起质变。导致速率大大降低。

linux2.4版本前的nio时序图

  1. 底层调用的了sendfile()方法，然后切换用户态（user space）->内核态（kemel space）。
  2. 从本地磁盘获取数据。获取的数据存储在内核态的内存空间内。
  3. 将内核缓存中的数据拷贝到socket缓冲中。
  4. 将socket缓存的数据发送。
  5. 发送完毕以后，切换内核态->用户态。继续执行我们编写的java代码。

可以看出，即便我们使用了nio，其实在我们的缓存中依旧会有一次内存拷贝。拷贝到socket buffer（也就是发送缓存区）中。

到这里我们可以看到，用户态已经不需要再缓存数据了。也就是少了用户态和系统态之间的数据拷贝过程。也少了两次用户态与内核态上下文切换的过程。但是还是不够完美。因为在底层还是执行了一次拷贝。

要想实现真真意义上的零拷贝，还是需要操作系统的支持，操作系统支持那就支持。不支持你代码写出花了也不会支持。所以在linux2.4版本以后，零拷贝进化为以下模式。

linux2.4版本后的nio时序图

这里的步骤与上面的步骤是类似的。看图可以看出，到这里内存中才真正意义上实现了零拷贝。

很多人就会发问了。为什么少了一次内核缓存的数据拷贝到socket缓存的操作？

不急，听我慢慢道来~

我们再来看另一张nio的流程图：

上面这个图稍稍有点复杂，都看到这里了，别半途而废。多看几遍是能看懂的！

首先第一条黑线我们可以看出，在nio只切换了两次用户态与内核态之间的上下文切换。

我们重点看这张图下面的部分。

首先我们将硬盘（hard drive）上的数据复制到内核态缓存中（kemel buffer）。然后发生了一次拷贝（cpu copy）到socket缓存中(socket buffer)。最后再通过协议引擎将数据发送出去。

在linux2.4版本前的的确是这样。但是！！！！

在linux2.4版本以后，上图中的从内核态缓存中（kemel buffer）的拷贝到socket缓存中(socket buffer)的就不再是数据了。而是对内核态缓存中数据的描述符（也就是指针）。协议引擎发送数据的时候其实是通过socket缓存中的描述符。找到了内核态缓存中的数据。再将数据发送出去。这样就实现了真正的零拷贝。

总结

我们花了两篇文章，一篇从jvm堆内存的角度出发（），以及本篇从操作体统底层出发来讲解零拷贝。足以说明零拷贝的重要性，各位可千万得重视哟，就算你觉得不重要，面试也是会经常被问到，如果你能把上面的流程讲明白，我相信一定也是一大亮点~

您可能感兴趣的文章:

如对本文有疑问， 点击进行留言回复！！

相关文章:

验证码：
最近更新的文章
大家感兴趣的文章
移动技术网