学习这件事，不在乎有没有人督促你，最重要的是在于你自己有没有觉悟和恒心。

温习中，会以笔记的形式记录下自我学习的过程。预计1月底之前更新完毕，请关注。

文章部分图片来源于视频笔记！！非我自画！！

netty的自我学习（一）—BIO、NIO、AIO的简单介绍

netty的自我学习（二）—初识NIO以及Buffer

netty的自我学习（三）—NIO的channel

netty的自我学习（四）—NIO的Selector(选择器)

netty的自我学习（五）—NIO之零拷贝

netty的自我学习（六）—Reactor模型以及Netty模型介绍

零拷贝基本介绍

零拷贝是网络编程的关键，很多性能优化都离不开。
在 Java 程序中，常用的零拷贝有 mmap(内存映射) 和 sendFile。那么，他们在 OS 里，到底是怎么样的一个的设计？我们分析 mmap 和 sendFile 这两个零拷贝
零拷贝不是拷贝，只是从操作系统角度，是没有cpu 拷贝

传统IO数据读写

File file = new File("test.txt");
RandomAccessFile raf = new RandomAccessFile(file, "rw");

byte[] arr = new byte[(int) file.length()];
raf.read(arr);

Socket socket = new ServerSocket(8080).accept();
socket.getOutputStream().write(arr);

传统IO拷贝分析

3次状态切换

从用户态切换到内核态(kernel context）
从内核态到用户态
在从用户态到内核态

4次拷贝次数

第一次拷贝：硬件上的数据做一次 DMA拷贝，拷贝到内核buffer(kernel buffer)
```
DMA: direct memory access直接内存拷贝(不使用CPU copy)
```
第二次拷贝：从内核buffer拷贝到用户buffer(user buffer)---cpu copy
第三次拷贝: 从用户buffer 拷贝到socket buffer ---cpu copy
第四次拷贝：从socket buffer 在做一次DMA拷贝到协议栈（protocol engine）

mmap 优化拷贝分析

mmap 通过内存映射，将文件映射到内核缓冲区，同时，用户空间可以共享内核空间的数据。这样，在进行网络传输时，就可以减少内核空间到用户控件的拷贝次数

3次状态切换

从用户态切换到内核态(kernel context）
从内核态到用户态
在从用户态到内核态

3次拷贝次数

第一次拷贝：硬件上的数据做一次 DMA拷贝，拷贝到内核buffer(kernel buffer)
```
DMA: direct memory access直接内存拷贝(不使用CPU)
```
第二次拷贝：由于mmap userBuffer和内核buffer可以共享数据，所以此时就不会在发生一次用户拷贝啦，因此数据可以直接在内核缓冲直接进行修改，修改完后在通过cpu 拷贝到socket buffer。---cpu copy
第三次拷贝：从socket buffer 在做一次DMA拷贝到协议栈（protocol engine）

sendFile 优化

sendFile 第一次优化

Linux 2.1 版本提供了 sendFile 函数，其基本原理如下：数据根本不经过用户态，直接从内核缓冲区进入到 Socket Buffer，同时，由于和用户态完全无关，就减少了一次上下文切换

2次状态切换

从用户态切换到内核态(kernel context）
从内核态到用户态

3次拷贝次数

第一次拷贝：硬件上的数据做一次 DMA拷贝，拷贝到内核buffer(kernel buffer)
```
DMA: direct memory access直接内存拷贝(不使用CPU)
```
第二次拷贝：使用cpu copy 从内核buffer 拷贝到socket buffer ---cpu copy
第三次拷贝：从socket buffer 在做一次DMA拷贝到协议栈（protocol engine）

sendFile 第2次优化

Linux 在 2.4 版本中，做了一些修改，避免了从内核缓冲区拷贝到 Socket buffer 的操作，直接拷贝到协议栈，从而再一次减少了数据拷贝.

2次状态切换

从用户态切换到内核态(kernel context）
从内核态到用户态

2次拷贝次数

第一次拷贝：硬件上的数据做一次 DMA拷贝，拷贝到内核buffer(kernel buffer)
```
DMA: direct memory access直接内存拷贝(不使用CPU)
```
第二次拷贝：从内核buffer在做一次DMA拷贝到协议栈（protocol engine）
这里其实有一次cpu 拷贝kernel buffer -> socket buffer 但是，拷贝的信息很少，比如lenght , offset , 消耗低，可以忽略. socket buffer 是灰色代表着极小的copy.

这就是真正的零拷贝。

零拷贝总结

零拷贝，是从操作系统的角度来说的。因为内核缓冲区之间，没有数据是重复的（只有 kernel buffer 有一份数据）。
零拷贝不仅仅带来更少的数据复制，还能带来其他的性能优势，例如更少的上下文切换，更少的 CPU 缓存伪共享以及无 CPU 校验和计算

mmap 和 sendFile 的区别

mmap 适合小数据量读写，sendFile 适合大文件传输。
mmap 需要 4 次上下文切换，3 次数据拷贝；sendFile 需要 3 次上下文切换，最少 2 次数据拷贝。
sendFile 可以利用 DMA 方式，减少 CPU 拷贝，mmap 则不能（必须从内核拷贝到 Socket 缓冲区）。

传统IO拷贝DEMO

package netty.nio.zerocopy;

import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.net.Socket;

public class OldIOClient {

    public static void main(String[] args) throws Exception {
        Socket socket = new Socket("localhost", 7001);

        String fileName = "protoc-3.6.1-win32.zip";
        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();
    }
}

package netty.nio.zerocopy;

import java.io.DataInputStream;
import java.net.ServerSocket;
import java.net.Socket;

//java IO 的服务器
public class OldIOServer {

    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(7001);

        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();
            }
        }
    }
}

NIO零拷贝DEMO

package netty.nio.zerocopy;

import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;

//服务器
public class NewIOServer {
   public static void main(String[] args) throws Exception {

       InetSocketAddress address = new InetSocketAddress(7001);

       ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

       ServerSocket serverSocket = serverSocketChannel.socket();

       serverSocket.bind(address);

       //创建buffer
       ByteBuffer byteBuffer = ByteBuffer.allocate(4096);

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

           int readcount = 0;
           while (-1 != readcount) {
               try {

                   readcount = socketChannel.read(byteBuffer);

               }catch (Exception ex) {
                  // ex.printStackTrace();
                   break;
               }
               //
               byteBuffer.rewind(); //倒带 position = 0 mark 作废
           }
       }
   }
}

package netty.nio.zerocopy;

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

public class NewIOClient {
   public static void main(String[] args) throws Exception {

       SocketChannel socketChannel = SocketChannel.open();
       socketChannel.connect(new InetSocketAddress("localhost", 7001));
       String filename = "protoc-3.6.1-win32.zip";

       //得到一个文件channel
       FileChannel fileChannel = new FileInputStream(filename).getChannel();

       //准备发送
       long startTime = System.currentTimeMillis();

       //在linux下一个transferTo 方法就可以完成传输
       //在windows 下 一次调用 transferTo 只能发送8m , 就需要分段传输文件
       //transferTo 底层使用到零拷贝
       long transferCount = fileChannel.transferTo(0, fileChannel.size(), socketChannel);

       System.out.println("发送的总的字节数 =" + transferCount + " 耗时:" + (System.currentTimeMillis() - startTime));

       //关闭
       fileChannel.close();

   }
}

第一次运行也可能是60毫秒左右。

互相讨论、共同进步

文章是笔者分享的学习笔记，若你觉得可以、还行、过得去、甚至不太差的话，可以“点赞”一下的哦。就此谢过!

持之以恒！