文档章节

彻底搞懂零拷贝

SEOwhywhy
 SEOwhywhy
发布于 08/19 17:44
字数 2344
阅读 3
收藏 0

  为了彻底搞懂零拷贝,我们趁热打铁,接着上一节来继续讲解零拷贝的底层原理。
  
  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缓存中的描述符。找到了内核态缓存中的数据。再将数据发送出去。这样就实现了真正的零拷贝。

© 著作权归作者所有

SEOwhywhy
粉丝 8
博文 155
码字总数 342404
作品 0
私信 提问
深入理解Vue的watch实现原理及其实现方式

理解Vue中Watch的实现原理和方式之前,你需要深入的理解MVVM的实现原理,如果你还不是很理解,推荐你阅读我之前的几篇文章: 彻底搞懂Vue针对数组和双向绑定(MVVM)的处理方式 vue.js源码解读...

wangweianger
2018/05/14
0
0
从零开始配置webpack(基于webpack 4 和 babel 7版本)

webpack启动后会从 Entry 里配置的 Module 开始递归解析 Entry 依赖的所有Module.每找到一个Module,就会根据配置的Loader去找出对应的转换规则,对Module进行转换后,再解析出当前的Module依...

大灰狼的小绵羊哥哥
04/13
0
0
年薪六十万的Python程序员第一道面试题就是算法!看我如何破解?

LRU算法在Python这种后端工程师面试中,是必出题。如果你不能够彻底理解,那么就是一道坎!此文带你快速理解LRU算法,然后仅用16行Python代码轻松实现一个基于LRU算法的缓存。 LRU:Least r...

Python资料
2018/03/09
0
0
价值99元的同步分享

戴铭,前滴滴出行技术专家,深度经历了移动开发和后端技术的演进过程,在组件化方案落地、工程动态化、大前端建设、应用开发阶段效率的提升、上线后各种难点问题的解决等方面的经验非常丰富。...

PetitBread
03/13
0
0
动态库的链接

零: 前言 一直没搞懂这三个之间的区别. 动态库的链接.png 一: target depnedencies(编译前) 这个选项只是告诉工程在运行的时候先去编译这里导入的库. 二:Link Binary With Libraries(编译时期...

Sunxxxxx丶
2017/09/04
0
0

没有更多内容

加载失败,请刷新页面

加载更多

centos 查看删除旧内核

1、查看系统中安装的内核 $ yum list installed | grep kernel 2、删除系统中旧内核 $ yum install yum-utils$ package-cleanup --oldkernels --count=2...

编程老陆
58分钟前
8
0
ES6

ES6:不改变原理的基础上,让API变得更简单 一、let:代替var用于声明变量 1、var的缺点: (1)声明提前 (2)没有块级作用域 2、let的优点: (1)组织了申明提前 (2)让let所在的块({}),...

wytao1995
今天
3
0
kubernetes 环境搭建 —— minikube

创建集群 minikube start 搭建好 k8s 集群后,可以查看集群的状态以及部署应用。主要用到的是 k8s 的 api,这通常需借助于 kutectl 命令行工具 基本操作 kubectl versionkubectl cluster-i...

lemos
今天
10
0
关于js混淆与反混淆还原操作

使用js的混淆加密,其目的是为了保护我们的前端代码逻辑,对应一些搞技术吃饭的公司来说,为了防止被竞争对手抓取或使用自己的代码,就会考虑如何加密,或者混淆js来达到代码保护。 1、为什么...

开源oschina
今天
12
0
用盛金公式解三次方程(ansi c版)

/* cc cubic.c -lm gcc cubic.c -lm Shengjin's Formulas Univariate cubic equation aX ^ 3 + bX ^ 2 + cX + d = 0, (a, b, c, d < R, and a!= 0). Multiple root disc......

wangxuwei
今天
9
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部