深入理解零拷贝

前言

这个词我们也经常在nio，netty，RocketMQ等框架中听到。字面意思就是数据不需要来回的拷贝，大大提升了系统的性能

基本概念

1.内核空间 / 用户空间

操作系统的核心是内核，独立于普通的应用程序，可以访问受保护的内存空间，也有访问底层硬件设备的所有权限。为了保证用户进程不能直接操作内核（kernel），保证内核的安全，操心系统将虚拟空间划分为两部分，一部分为内核空间，一部分为用户空间。

2.缓冲区

缓冲区，以及缓冲区如何工作，是所有 I/O 的基础。所谓“输入／输出”讲的无非就是把数据移进或移出缓冲区。进程执行 I/O 操作，归结起来，也就是向操作系统发出请求，让它要么把缓冲区里的数据排干（写），要么用数据把缓冲区填满（读）。进程使用这一机制处理所有数据进出操作。操作系统内部处理这一任务的机制，其复杂程度可能超乎想像，但就概念而言，却非常直白易懂。首先，硬件通常不能直接访问用户空间 。其次，像磁盘这样基于块存储的硬件设备操作的是固定大小的数据块，而用户进程请求的可能是任意大小的或非对齐的数据块。在数据往来于用户空间与存储设备的过程中，内核负责数据的分解、再组合工作，因此充当着中间人的角色。

这样挺浪费空间的，每次都需要把内核空间的数据拷贝到用户空间中，所以零拷贝就是为了解决这种问题
关于零拷贝提供了两种方式分别是：mmap+write方式，sendfile方式；

虚拟内存 百科
虚拟地址可以指向同一个物理内存地址，利用这个就可以把内核空间地址和用户空间的虚拟地址映射到同一个物理地址，这样DMA就可以填充对内核和用户空间进程同时可见的缓冲区了。

mmap+write
mmap是一种内存映射文件的方法，实现文件磁盘地址和进程虚拟地址空间中一段虚拟地址的一一对映关系；这样就可以省掉原来内核read缓冲区copy数据到用户缓冲区

sendfile
相对于传统IO，文件数据被copy至内核缓冲区，再从内核缓冲区copy至内核中socket相关的缓冲区，减少了内核缓冲区到user缓冲区

Java零拷贝

1.MappedByteBuffer

nio提供的FileChannel，可以在一个打开的文件和MappedByteBuffer之间建立一个虚拟内存映射,调用get()方法会从磁盘中获取数据，此数据反映该文件当前的内容，调用put()方法会更新磁盘上的文件，并且对文件做的修改对其他阅读者也是可见的；下面看一个简单的读取实例，然后在对MappedByteBuffer进行分析：

主要通过FileChannel提供的map()来实现映射，map()方法如下：

public abstract MappedByteBuffer map(MapMode mode,  long position, long size)

MapMode：映射的模式，可选项包括：READ_ONLY，READ_WRITE，PRIVATE；
Position：从哪个位置开始映射，字节数的位置；
Size：从position开始向后多少个字节；

重点看一下MapMode，请两个分别表示只读和可读可写，当然请求的映射模式受到Filechannel对象的访问权限限制，如果在一个没有读权限的文件上启用READ_ONLY，将抛出NonReadableChannelException；PRIVATE模式表示写时拷贝的映射，意味着通过put()方法所做的任何修改都会导致产生一个私有的数据拷贝并且该拷贝中的数据只有MappedByteBuffer实例可以看到；该过程不会对底层文件做任何修改，而且一旦缓冲区被施以垃圾收集动作（garbage collected），那些修改都会丢失；

2.DirectByteBuffer

DirectByteBuffer继承于MappedByteBuffer，从名字就可以猜测出开辟了一段直接的内存，但是不会占用jvm的内存空间

ByteBuffer directByteBuffer = ByteBuffer.allocateDirect(100);

如上开辟了100字节的直接内存空间；

3.Channel-to-Channel传输

经常需要从一个位置将文件传输到另外一个位置，FileChannel提供了transferTo()方法用来提高传输的效率
，接口定义如下：

public abstract long transferTo(long position, long count, WritableByteChannel target)    throws IOException;

几个参数也比较好理解，分别是开始传输的位置，传输的字节数，以及目标通道；transferTo()允许将一个通道交叉连接到另一个通道，而不需要一个中间缓冲区来传递数据。
举个栗子

public class ChannelTransfer {
   public static void main(String[] argv) throws Exception {
       String files[]=new String[1];
       files[0]="filePatht";
       catFiles(Channels.newChannel(System.out), files);
   }

   private static void catFiles(WritableByteChannel target, String[] files)
           throws Exception {
       for (int i = 0; i < files.length; i++) {
           FileInputStream fis = new FileInputStream(files[i]);
           FileChannel channel = fis.getChannel();
           channel.transferTo(0, channel.size(), target);
           channel.close();
           fis.close();
       }
   }
}

netty 零拷贝

netty提供了零拷贝的buffer，在传输数据时，最终处理的数据会需要对单个传输的报文，进行组合和拆分，netty通过提供的Composite(组合)和Slice(拆分)两种buffer来实现零拷贝

报文被分成了两个ChannelBuffer，这两个Buffer对我们上层的逻辑(HTTP处理)是没有意义的。 但是两个ChannelBuffer被组合起来，就成为了一个有意义的HTTP报文，这个报文对应的ChannelBuffer，才是能称之为”Message”的东西。

部分源码

  public class CompositeChannelBuffer extends AbstractChannelBuffer {
    
       private final ByteOrder order;
       
      // 所有ChannelBuffer的引用
       private ChannelBuffer[] components;
       
       // 记录每个buffer的起始位置
       private int[] indices;
       
       //记录上一次访问的ComponentId
       private int lastAccessedComponentId;
       
       private final boolean gathering;
    
       public byte getByte(int index) {
           int componentId = componentId(index);
           return components[componentId].getByte(index - indices[componentId]);
       }

CompositeChannelBuffer并不会开辟新的内存并直接复制所有ChannelBuffer内容，而是直接保存了所有ChannelBuffer的引用，并在子ChannelBuffer里进行读写，实现了零拷贝。

/**
 * Setup this ChannelBuffer from the list
 */
private void setComponents(List<ChannelBuffer> newComponents) {
    assert !newComponents.isEmpty();

    // Clear the cache.
    lastAccessedComponentId = 0;

    // Build the component array.
    components = new ChannelBuffer[newComponents.size()];
    for (int i = 0; i < components.length; i ++) {
        ChannelBuffer c = newComponents.get(i);
        if (c.order() != order()) {
            throw new IllegalArgumentException(
                    "All buffers must have the same endianness.");
        }

        assert c.readerIndex() == 0;
        assert c.writerIndex() == c.capacity();

        components[i] = c;
    }

    // Build the component lookup table.
    indices = new int[components.length + 1];
    indices[0] = 0;
    for (int i = 1; i <= components.length; i ++) {
        indices[i] = indices[i - 1] + components[i - 1].capacity();
    }

    // Reset the indexes.
    setIndex(0, capacity());
}

通过代码可以看到该方法的功能就是将一个ChannelBuffer的List给组合起来。它首先将List中得元素放入到components数组中，然后创建indices用于数据的查找，最后使用setIndex来重置指针。这里需要注意的是setIndex(0, capacity())会将读指针设置为0，写指针设置为当前Buffer的长度，这也就是前面需要做assert c.readerIndex() == 0和assert c.writerIndex() == c.capacity()这两个判断的原因，否则很容易会造成数据重复读写的问题，所以Netty推荐我们使用ChannelBuffers.wrappedBuffer方法来进行Buffer的合并，因为在该方法中Netty会通过slice()方法来确保构建CompositeChannelBuffer是传入的所有子Buffer都是符合要求的。

RocketMQ零拷贝

RocketMQ的消息采用顺序写到commitlog文件，然后利用consume queue文件作为索引；RocketMQ采用零拷贝mmap+write的方式来回应Consumer的请求；

总结

不管是虚拟内存，还是mmap+write，或者sendfile方式， 用java 的方式来看，对象实例只有一个， 其他都是在搬动引用