Java网络编程（10）零拷贝

前言

前面已经学习了NIO的基本思想和三大组件：Buffer、Channel、Selector，接下来学习一种性能优化：零拷贝

目录

1. 传统IO经历的拷贝
2. 传统IO发送文件
3. 优化
   3.1. MMAP优化
   3.2. sendFile优化
4. NIO中的实现
5. 总结

传统IO经历的拷贝

通过流一次read、write拷贝文件
需要经过四次上下文切换和四次拷贝（两次DMA拷贝，两次CPU拷贝）

具体步骤：

1. 程序调用read（）方法，系统从用户态（User Context）切换到内核态（kernel Context），磁盘（hard driver）数据通过DMA copy（第一次拷贝）到内核缓冲区（Kernel buffer）。DAM拷贝是DMA处理器直接将硬盘数据通过总线传输到内存，不需要经过CPU
2. 系统有内核态切换到用户态（第二次上下文切换），将内核缓冲区的数据CPU copy（第二次拷贝）到用户缓冲区
3. 程序调用write（）方法，系统从用户态切换到内核态（第三次上下文切换），将用户缓冲区的数据CPU copy（第三次拷贝）到网络缓冲区（Socket buffer）
4. 系统从内核态切换到用户态（第四次上下文切换），网络缓冲区的数据通过DMA copy（第四次拷贝）传输到网卡的驱动(存储缓冲区Protocol engine)中

关于这些操作系统的名词这个解释：用户空间与内核空间，进程上下文与中断上下文[总结]

传统IO传输文件中四次上下文切换，四次拷贝需要很大的开销
四次拷贝中两次DMA拷贝不可避免，一般说的零拷贝是指仅两次DMA拷贝

传统IO发送文件

服务器：

package com.company.ZeroCopy;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;

public class OldSever {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        try {
            serverSocket = new ServerSocket();

        serverSocket.bind(new InetSocketAddress(9999));
        while (true) {
            Socket socket = serverSocket.accept();
            DataInputStream inputStream = new DataInputStream(socket.getInputStream());
            byte[] bytes=new byte[4096];
            while (true){
                int read = inputStream.read(bytes, 0, bytes.length);
                if(read == -1){
                    break;
                }
            }
        }
        } catch (IOException e) {

        }
    }
}

客户端：

package com.company.ZeroCopy;

import java.io.*;
import java.net.Socket;

public class OldClient {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1",9999);
        //获得文件
        InputStream inputStream=new FileInputStream("redis.zip");
        //网络传输
        DataOutputStream dataOutputStream = new DataOutputStream(socket.getOutputStream());

        byte[] bytes=new byte[4096];

        long readByte;
        long total=0;

        long start = System.currentTimeMillis();

        while ((readByte = inputStream.read(bytes)) >= 0){
            total += readByte;
            dataOutputStream.write(bytes);
        }
        System.out.println("发送总字节数："+total+", 耗时："+(System.currentTimeMillis()-start)+" ms");

        dataOutputStream.close();
        inputStream.close();
        socket.close();
    }
}

传输一个1.23M的文件需要12ms

优化

MMAP优化

MMAP通过内存映射的方式，使用户缓冲区和内核读缓冲区的内存地址为同一内存地址，即用户空间共享内核空间的数据，进行网络传输时可以减少一次CPU copy

sendFile优化

Linux2.1提供的sendFile函数：

数据不经过用户空间，直接从内核缓冲区进入Socket buffer，然后继续DMA copy

sendFile方法仅两次上下文切换和一次CPU copy

Linux2.4版本，再次进行了修改，避免了从内核缓冲区到Socket Buffer的CPU copy（仅拷贝一些说明信息），直接通过DMA copy将内核缓冲区的数据拷贝到存储缓冲区

这样几乎就是零拷贝了（0次CPU拷贝）

NIO中的实现

通过文件通道的transferTo可以实现零拷贝（transferFrom也是）

客户端：

package com.company.ZeroCopy;

import java.io.FileInputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.SocketChannel;

public class ZeroCopyClient {
    public static void main(String[] args) throws IOException {
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.connect(new InetSocketAddress("localhost",9999));

        FileInputStream fileInputStream = new FileInputStream("redis.zip");
        FileChannel channel = fileInputStream.getChannel();

        ByteBuffer byteBuffer=ByteBuffer.allocate(4096);

        long start=System.currentTimeMillis();
        //transferTo在Windows下一次只能发送8M的数据
        //在Linux下可以全部发送
        long fileSize = channel.transferTo(0, channel.size(), socketChannel);

        System.out.println("发送总字节数："+fileSize+" ,耗时："+(System.currentTimeMillis()-start)+" ms");

        //仅查看拷贝时间，不真正的发送

        channel.close();
        socketChannel.close();
    }
}

服务器：

package com.company.ZeroCopy;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;

public class ZeroCopyServer {
    public static void main(String[] args) throws IOException {
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.socket().bind(new InetSocketAddress(9999));

        ByteBuffer byteBuffer = ByteBuffer.allocate(4096);

        while (true) {
            SocketChannel socketChannel = serverSocketChannel.accept();

            int read = 0;

            while (read != -1){
                read = socketChannel.read(byteBuffer);
                //循环读入，需要rewind缓冲区
                byteBuffer.rewind();
            }


        }
    }
}

实验结果：时间有了明显的减少

总结

1. 传统IO传输文件仅在客户端发送需要四次上下文切换，四次拷贝（两次CPU拷贝，两次DMA拷贝）
2. 零拷贝说的是0次CPU拷贝，DMA拷贝无法避免
3. MMAP通过文件映射，使用户空间可以共享内核空间数据，减少了一次CPU拷贝，该种方法仅适用传输小文件
4. sendFile最初是不经过用户空间，直接从内核空间CPU copy到Socket Buffer，减少了一次上下文切换，还存在一次CPU拷贝
5. senFile在Linux2.4再次修改，可以直接从内核空间拷贝到存储缓冲区（仅CPU拷贝一些说明信息到Socket Buffer），近乎是零拷贝