完全搞懂零拷贝

　　为了完全搞懂零拷贝，咱们趁热打铁，接着上一节来继续讲解零拷贝的底层原理。
　　
　　2|0感觉一下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端口，死循环不断接受数据。
　　
　　2|1传统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实际表现并非咱们想象的那样直接将文件读到内存，而后发送。
　　
　　实际状况是什么样的呢？咱们在后续分析。
　　
　　2|2NIO传输
　　
　　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。
　　
　　3|0底层原理
　　
　　num_rows, num_cols = img_mat.shape[:2]
　　
　　tx=5
　　
　　ty=0
　　
　　translation_matrix =www.meiwanyule.cn  np.float32([ [1,0,tx], [0,1,ty] ])
　　
　　img_translation = cv2.warpAffine(img_mat, translation_matrix, (num_cols, num_rows),borderValue=(0,0,0))
　　
　　效果以下
　　
　　图像旋转
　　
　　图像的旋转其实和平移的原理是相似的,opencv里提供了一个api帮咱们去获取旋转矩阵.咱们只须要给出旋转中心和旋转角度便可.
　　
　　cv::Mat src = cv::imread(www.yongshenyuL.com "lenna.jpg"www.yuxinyulept.com );
　　
　　cv::Mat dst;
　　
　　//旋转角度
　　
　　double angle = 45;
　　
　　cv::Size src_sz = src.size();
　　
　　cv::Size dst_sz(src_sz.height, src_sz.width);
　　
　　int len = std::max(www.yacuangpt.com  src.cols, src.rows);
　　
　　/http://blog.sina.com.cn/u/5125835408
　　
　　https://www.douban.com/people/187906486/
　　
　　cv::Point2f center(www.hnawesm.com / 2., len / 2.);
　　
　　//获取旋转矩阵（2x3矩阵）
　　
　　cv::Mat rot_mat = cv::getRotationMatrix2D(center, angle, 1.0);
　　
　　//根据旋转矩阵进行仿射变换
　　
　　cv::warpAffine(src,www.51kunlunyule.com dst, rot_mat, dst_sz);
　　
　　//显示旋转效果
　　
　　cv::imshow("image", src);
　　
　　cv::imshow("result", dst);
　　
　　cv::waitKey(0);
　　
　　return 0;
　　
　　你们也能够用本身的电脑运行一下上述代码，看看NIO传输一个文件比IO传输一个文件快多少。
　　
　　在上诉代码中，楼主这里指定的缓存只有4096个字节，而传送的文件大小有125581592个字节。
　　
　　在前面咱们分析过，对于传统的IO而言，读取的缓存满了之后会有两次零拷贝过程。那么换算下来传输这个文件大概在内存中进行了6w屡次无心义的内存拷贝，这6w屡次拷贝在个人笔记本上大概所耗费的时间就是300ms左右。这就是致使NIO比传统IO快的更本缘由。
　　
　　3|1传统IO底层时序图
　　
　　由上图咱们能够看到。当咱们想将磁盘中的数据经过网络发送的时候，
　　
　　底层调用的了sendfile()方法，而后切换用户态（User space）->内核态（Kemel space）。
　　
　　从本地磁盘获取数据。获取的数据存储在内核态的内存空间内。
　　
　　将数据复制到用户态内存空间里。
　　
　　切换内核态->用户态。
　　
　　用户操做数据，这里就是咱们编写的java代码的具体操做。
　　
　　调用操做系统的write()方法，将数据复制到内核态的socket buffer中。
　　
　　切换用户态->内核态。
　　
　　发送数据。
　　
　　发送完毕之后，切换内核态->用户态。继续执行咱们编写的java代码。
　　
　　由上图能够看出。传统的IO发送一次数据，进行了两次“无心义”的内存拷贝。虽然内存拷贝对于整个IO来讲耗时是能够忽略不计的。可是操做达到必定次数之后，就像咱们上面案例的代码。就会由量变引发质变。致使速率大大下降。
　　
　　3|2linux2.4版本前的NIO时序图
　　
　　转存失败
　　
　　从新上传
　　
　　取消
　　
　　底层调用的了sendfile()方法，而后切换用户态（User space）->内核态（Kemel space）。
　　
　　从本地磁盘获取数据。获取的数据存储在内核态的内存空间内。
　　
　　将内核缓存中的数据拷贝到socket缓冲中。
　　
　　将socket缓存的数据发送。
　　
　　发送完毕之后，切换内核态->用户态。继续执行咱们编写的java代码。
　　
　　能够看出，即使咱们使用了NIO，其实在咱们的缓存中依旧会有一次内存拷贝。拷贝到socket buffer（也就是发送缓存区）中。
　　
　　到这里咱们能够看到，用户态已经不须要再缓存数据了。也就是少了用户态和系统态之间的数据拷贝过程。也少了两次用户态与内核态上下文切换的过程。可是仍是不够完美。由于在底层仍是执行了一次拷贝。
　　
　　要想实现真真意义上的零拷贝，仍是须要操做系统的支持，操做系统支持那就支持。不支持你代码写出花了也不会支持。因此在linux2.4版本之后，零拷贝进化为如下模式。
　　
　　3|3linux2.4版本后的NIO时序图
　　
　　转存失败
　　
　　从新上传
　　
　　取消
　　
　　这里的步骤与上面的步骤是相似的。看图能够看出，到这里内存中才真正意义上实现了零拷贝。
　　
　　不少人就会发问了。为何少了一次内核缓存的数据拷贝到socket缓存的操做？
　　
　　不急，听我慢慢道来~
　　
　　咱们再来看另外一张NIO的流程图：
　　
　　转存失败
　　
　　从新上传
　　
　　取消
　　
　　上面这个图稍稍有点复杂，都看到这里了，别半途而废。多看几遍是能看懂的！
　　
　　首先第一条黑线咱们能够看出，在NIO只切换了两次用户态与内核态之间的上下文切换。
　　
　　咱们重点看这张图下面的部分。
　　
　　首先咱们将硬盘（hard drive）上的数据复制到内核态缓存中（kemel buffer）。而后发生了一次拷贝（CPU copy）到socket缓存中(socket buffer)。最后再经过协议引擎将数据发送出去。
　　
　　在linux2.4版本前的的确是这样。可是！！！！
　　
　　在linux2.4版本之后，上图中的从内核态缓存中（kemel buffer）的拷贝到socket缓存中(socket buffer)的就再也不是数据了。而是对内核态缓存中数据的描述符（也就是指针）。协议引擎发送数据的时候实际上是经过socket缓存中的描述符。找到了内核态缓存中的数据。再将数据发送出去。这样就实现了真正的零拷贝。