深入理解NIO零拷贝

最新推荐文章于 2023-06-30 22:19:01 发布
最新推荐文章于 2023-06-30 22:19:01 发布
阅读量835 收藏 1
点赞数
分类专栏： NIO 文章标签： NIO Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaowei132/article/details/95766724
版权

什么是零拷贝

张老师的学生无处不在，哈哈哈！@张龙

  传统的IO在进行文件传输的时候，涉及多次数据从内核缓冲区到用户缓存区的双向拷贝及用户态和内核态的转换，因此效率低下；NIO的零拷贝实现了从内核缓冲区到用户缓冲区的双向0拷贝，并取消了内核缓冲区从kernel buffer到socket buffer的拷贝，同时也减少了多次用户态和内核态之间的转换，因此在涉及Socket网络传输的时候效率甚高。

传统的IO实现

  我们以一个客户端发送一个文件到服务端的例子来说明。先上两段代码：

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

/**
 * @author pulil
 * @version V1.0
 * @Title
 * @Description
 * @date 2019-07-13 下午3:03
 */
public class OldIOServer {

    public static void main(String[] args) throws Exception {
        //创建一个ServerSocket并监听8888端口
        ServerSocket serverSocket = new ServerSocket(8888);

        while(true) {
            //阻塞方法，获得连接的socket对象
            Socket socket = serverSocket.accept();
            //通过装饰器模式获取DataInputStream
            DataInputStream dataInputStream = new DataInputStream(socket.getInputStream());

            int totalCount = 0;
            //读取数据
            try {
                byte[] buffer = new byte[4096];

                int read = 0;
                while((read = dataInputStream.read(buffer)) > 0) {
                    totalCount += read;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("服务端接受字节数:" + totalCount);
        }
    }
}
Client端
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.net.Socket;

/**
 * @author pulil
 * @version V1.0
 * @Title
 * @Description
 * @date 2019-07-13 下午4:21
 */
public class OldIOClient {

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

        Socket socket = new Socket("localhost",8888);

        String fileName = "本地磁盘路径/somefile.zip";//大小953.4 MB
        InputStream inputStream = new FileInputStream(fileName);

        DataOutputStream dataOutputStream = new DataOutputStream(socket.getOutputStream());

        byte[] buffer = new byte[4096];
        int readCount = 0;
        long total = 0;

        long startTime = System.nanoTime();

        while((readCount = inputStream.read(buffer)) >= 0) {
            total += readCount;
            dataOutputStream.write(buffer,0,readCount);
        }

        System.out.println("发送总字节数：" + total + ", 耗时 ：" + (System.nanoTime() - startTime)/1000000);

        dataOutputStream.close();
        socket.close();
        inputStream.close();
    }
}
运行结果
//客户端运行结果
发送总字节数：953398669, 耗时 ：3730

//服务器端运行结果
服务端接受字节数:953398669

  本例子发送了一个953.4 MB的文件，共耗时3730ms。

传统IO执行过程

在这里插入图片描述
传统IO之所以慢，客户端在进行网络传输的时候需要经历上图步骤：

  1. JVM发出read系统调用
  2. 操作系统切换到内核态（限linux和unix，第一次切换），操作系统通过DMA（直接内存访问）将数据读取到内核缓冲区（第一次读取拷贝）
  3. 操作系统将数据拷贝到用户缓冲区（第二次拷贝），read系统调用返回；操作系统由内核态切换回用户态（第二次切换）
  4. JVM循环处理代码，并发送write系统调用
  5. 操作系统再次由用户态切换到内核态（第三次切换），并将用户缓冲区的数据拷贝到内核缓冲区中（第三次拷贝）
  6. 操作系统将内核缓冲区中的内容拷贝到socket buffer（第四次拷贝）中
  7. 协议引擎（protocol engine）从socket buffer中获取数据并将数据发送，write系统调用返回，内核态切换回用户态（第四次切换）
传统IO的流程总结

由此可见，传统的IO从硬盘上读取一个文件发送到远程服务器，需要经历

  • 一次从硬件的读取拷贝
  • 三次数据的拷贝（两次是内核空间和用户空间之间的拷贝，一次是内核空间之内的拷贝）
  • 四次的上下文切换。

这就是造成传统IO速度慢的原因。用户空间唯一起到的作用就是中转的作用，其他事情并没有做。

NIO零拷贝的做法(Linux 2.4之前)

一种优化-sendfile()系统调用的做法
在这里插入图片描述

步骤
  1. JVM发送sendfile系统调用
  2. 用户态切换到内核态（第一次切换），通过DMA从硬件上加载文件到内核缓冲区（第一次读取拷贝）
  3. 将数据从内核缓冲区拷贝至socket buffer中（第二次拷贝），注意是完整的数据拷贝
  4. 协议引擎从socket buffer中读取数据并发送，sendfile系统调用返回，内核态切换为用户态（第二次切换）
sendfile零拷贝总结，该模式下涉及了：
  • 两次上下文的切换
  • 一次读取拷贝
  • 一次内核态下的拷贝

sendfile零拷贝的优化（linux2.4开始）

在这里插入图片描述
可以看到，从linux2.4开始之后的sendfile做了一个很大的优化，就是使用scatter/gather，减少了一次内核状态下的拷贝，具体如下：

首先介绍一下Scatter，官方文档如下

  1. Scattering：在读取的时候可以不只是读取到一个buffer中，而是读取到多个buffer中
/**
* A channel that can read bytes into a sequence of buffers.
*
* <p> A <i>scattering</i> read operation reads, in a single invocation, a
* sequence of bytes into one or more of a given sequence of buffers.
* Scattering reads are often useful when implementing network protocols or
* file formats that, for example, group data into segments consisting of one
* or more fixed-length headers followed by a variable-length body.  Similar
* <i>gathering</i> write operations are defined in the {@link
* GatheringByteChannel} interface.  </p>
*
*
* @author Mark Reinhold
* @author JSR-51 Expert Group
* @since 1.4
*/
public interface ScatteringByteChannel extends ReadableByteChannel
  1. Gathering：在写的时候，可以将多个buffer中的内容合并写出去
/**
* A channel that can write bytes from a sequence of buffers.
*
* <p> A <i>gathering</i> write operation writes, in a single invocation, a
* sequence of bytes from one or more of a given sequence of buffers.
* Gathering writes are often useful when implementing network protocols or
* file formats that, for example, group data into segments consisting of one
* or more fixed-length headers followed by a variable-length body.  Similar
* <i>scattering</i> read operations are defined in the {@link
* ScatteringByteChannel} interface.  </p>
*
*
* @author Mark Reinhold
* @author JSR-51 Expert Group
* @since 1.4
*/
public interface GatheringByteChannel extends WritableByteChannel
升级后的sendfile零拷贝 在这里插入图片描述

从linux2.4版本之后，对于底层的文件描述符做了修改，这里面涉及一个gather调用，gather可以实现将多个buffer中将数据汇集到一起写入网络中。

  1. JVM发送sendfile系统调用
  2. 操作系统从用户态切换到内核态，并通过DMA copy从hard drive中将数据拷贝到kernel buffer中，在此同时，会直接将文件描述符(并不是整个数据)写入socket buffer中，文件描述符保存了数据在kernel buffer中的内存保存点以及长度，这样就好像数据被直接写入了socket channel中一样
  3. 协议引擎（protocol engine）使用gather从kernel buffer和socket buffer合并将数据发送出去
  4. 上下文从内核态切换到用户态

这样来看，整个操作过程中，只涉及必要的两次必要的上下文切换及一次必要的数据从硬件的读取拷贝，内核缓冲区的kernel buffer拷贝到socket buffer中仅仅拷贝了两个指针，因此真正完成了数据的零拷贝。性能当然大大的提高喽。

sendfile例子如下

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

/**
 * @author pulil
 * @version V1.0
 * @Title
 * @Description
 * @date 2019-07-13 下午4:26
 */
public class NewIOClient {

    public static void main(String[] args) throws Exception {
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.connect(new InetSocketAddress("localhost",8888));
        socketChannel.configureBlocking(true);

        String fileName = "本地磁盘路径/somefile.zip";//953.4 MB

        FileChannel fileChannel = new FileInputStream(fileName).getChannel();

        long startTime = System.nanoTime();

        //一行代码实现0拷贝，将文件channel中的内容直接写到SocketChannel中
        long transferCount = fileChannel.transferTo(0,fileChannel.size(),socketChannel);

        System.out.println("发送总字节数：" + transferCount + ", 耗时 ：" + (System.nanoTime() - startTime)/1000000);

        fileChannel.close();
        socketChannel.close();
    }
}

运行结果

//客户端输出
发送总字节数：953398669, 耗时 ：786

//服务器端输出
服务端接受字节数:953398669

可以看出，发送同样的数据，耗时仅786ms，比传统的IO执行时间3730ms足足快了有4倍还多，推荐大家使用NIO进行网络传输！！！

假装自己是一个华丽的分割线

最后给大家一个Scatter和Gather的小栗子

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Arrays;

/**
 * @author pulil
 * @version V1.0
 * @Title
 * @Description
 * @date 2019-07-08 下午5:38
 */
public class NioTest11 {
    /**
     * Buffer的Scattering和Gathering
     * Scattering：在读取的时候可以不只是读取到一个buffer中，而是读取到一个buffer数组中
     * Gathering：在写的时候，可以将一个buffer数组中的内容写出去
     *
     * 应用：比如在网络传输中，头信息是10个字节，后面的是消息体
     * 拿就可以天然的将头信息和消息体分到两个buffer中，而不是读到一个buffer中再进行解析
     */

    public static void main(String[] args) throws Exception {
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        InetSocketAddress address = new InetSocketAddress(8888);
        serverSocketChannel.socket().bind(address);

        int messageLength = 2 + 3 + 4;

        //构造buffer数组并初始化
        ByteBuffer[] buffers = new ByteBuffer[3];

        buffers[0] = ByteBuffer.allocate(2);
        buffers[1] = ByteBuffer.allocate(3);
        buffers[2] = ByteBuffer.allocate(4);

        SocketChannel socketChannel = serverSocketChannel.accept();

        while(true) {
            int bytesRead = 0;
            while(bytesRead < messageLength) {
                //将数据读取到buffers中
                long r = socketChannel.read(buffers);
                bytesRead += r;

                System.out.println("bytesRead:" + bytesRead);

                Arrays.asList(buffers).stream().map(buffer -> "position:" + buffer.position() + ", limit: " + buffer.limit())
                        .forEach(System.out::println);
            }

            //反转
            Arrays.asList(buffers).forEach(buffer-> {
                buffer.flip();
            });

            //写入
            long bytesWritten = 0;
            while(bytesWritten < messageLength) {
                long r = socketChannel.write(buffers);
                bytesWritten += r;
            }

            Arrays.asList(buffers).forEach(buffer->{
                buffer.clear();
            });

            System.out.println("bytesRead: " + bytesRead + ", butesWritten: " + bytesWritten + ", messageLength: " + messageLength);
        }
    }
}
小学生_
关注
专栏目录
NIO优化底层原理和零拷贝
Charte的博客
02-07 932
读取磁盘数据的时候，之所以要发生上下文切换，这是因为用户空间没有权限操作磁盘或网卡，内核的权限最高，这些操作设备的过程都需要交由操作系统内核来完成，所以一般要通过内核去完成某些任务的时候，就需要使用操作系统提供的系统调用函数。
深入分析零拷贝的原理，彻底掌握Netty、Kafka、RocketMQ高效率读写的秘诀
静待花开
04-09 3318
本文深入探究零拷贝的原理，从操作系统开始层层递进的分析了数据传输的各个相关组件及流程，直观透彻的呈现了零拷贝的原理和优点。
nio与零拷贝
weixin_44032502的博客
03-23 302
零拷贝一、零拷贝原理二、nio零拷贝 一、零拷贝原理 传统io mmap： mmap 通过内存映射，将文件映射到内核缓冲区，同时，用户空间可以共享内核空间的数据。这样，在进行网络传输时，就可以减少内核空间到用户控件的拷贝次数。 sendFile： Linux 2.1 版本 提供了 sendFile 函数，其基本原理如下：数据根本不经过用户态，直接从内核缓冲区进入到 Socket Buffer，同时，由于和用户态完全无关，就减少了一次上下文切换 零拷贝从操作系统角度，是没有cpu 拷贝 sendFile优
有必要了解一下Linux中零拷贝原理 | NIO零拷贝技术实践
东升的思考
09-23 436
本文导读：什么是零拷贝传统 IO 数据拷贝原理什么是 DMAsendfile 数据零拷贝原理mmap 数据零拷贝原理Java 中 NIO 零拷贝实现Jav...
NIO与零拷贝
HX_2021
08-12 147
1、基本介绍 零拷贝是网络编程的关键，很多性能优化都离不开； 在 Java 程序中，常用的零拷贝有mmap(内存映射) 和 sendFile。那么，他们在OS里，到底是怎么样的一个的设计？我们分析mmap和sendFile这两个零拷贝； 另外我们看下NIO中如何使用零拷贝； 我们说零拷贝，是从操作系统的角度来说的。因为内核缓冲区之间，没有数据是重复的（只有 kernel buffer有一份数据）； 零拷贝不仅仅带来更少的数据复制，还能带来其他的性能优势，例如更少的上下文切换，更少的CPU
NIO零拷贝
眼前一座山，踏平它
09-08 231
在Java体系的NIO和Netty中都存在着零拷贝这么一个东西，这项技术可以提升数据的读写速度，那到底什么是零拷贝呢，下面这张图可以很详细的说明。 在发送系统调用sendfile之前，处于用于上下文，之后切换到内核上下文进行系统调用 syscall sendfile，调用完成文件发送完成之后切换回用户上下文。其中在内核空间发生的事情主要过程是通过系统驱动的DMA(直接存储器存取，是一种快速传...
深入理解零拷贝技术
夜凄凉
03-08 152
零拷贝技术是一个思想，指的是指计算机执行操作时，CPU 不需要先将数据从某处内存复制到另一个特定区域。可见，零拷贝的特点是 CPU 不全程负责内存中的数据写入其他组件，CPU 仅仅起到管理的作用。但注意，零拷贝不是不进行拷贝，而是 CPU 不再全程负责数据拷贝时的搬运工作。如果数据本身不在内存中，那么必须先通过某种方式拷贝到内存中（这个过程 CPU 可以不参与），因为数据只有在内存中，才能被转移，才能被 CPU 直接读取计算。sendfilemmapsplice直接 Direct I/O。
Java NIO中的零拷贝技术原理解析
# 1. Java NIO概述 ### 1.1 传统I/O和NIO的区别 传统的I/O（Input/Output）模型通过字节流和字符流进行数据的输入和输出操作，使用阻塞式的方式，在处理输入输出时需要等待数据的...这种方式涉及两次数据的拷贝，即
深入理解NIO系列 - Channel详解
I Have A Dream
03-04 4192
Channel简介 在Java NIO中，主要有三大基本的组件：Buffer、Channel和Selector，前面两篇文章我们具体介绍了Selector和Buffer,老规矩，就让我们继续慢慢地揭开Channel的神秘面纱吧！ 在Java NIO的世界中，Selector是中央控制器，Buffer是承载数据的容器，而Channel可以说是最基础的门面，它是本地I/O设备、网络I/O的通信桥梁，只...
NIO效率高的原理之零拷贝与直接内存映射
最新发布
weixin_43398645的博客
06-30 211
在UNIX和Linux系统中，调用这个方法会引起sendfile()系统调用，实现了数据直接从内核的读缓冲区传输到套接字缓冲区，避免了用户态(User-space) 与内核态(Kernel-space) 之间的数据拷贝。对垃圾回收停顿的改善。磁盘到内核空间属于DMA拷贝，用户空间与内核空间之间的数据传输并没有类似DMA这种可以不需要CPU参与的传输方式，因此用户空间与内核空间之间的数据传输是需要CPU全程参与的（如上图所示）。但是，这一次，数据被写入一个不同的缓冲区，一个与目标套接字相关联的缓冲区。
NIO底层原理及零拷贝原理图解
CBC Java技术博客
06-06 172
深入分析NIO的零拷贝
皇甫嗷嗷叫
06-25 300
本章还是关于NIO的概念铺底，有关NIO相关的代码，我还是希望大家闲余时间取网上找一下有关使用JDK NIO开发服务端、客户端的代码，我会取写这些，但是具体的代码我不会很详细的取介绍，下一章的话可能就要上代码了，具体的规划如下： 讲一下NIO基础API的使用、分析Netty的核心思想，使用Reactor模式仿写一个多线程版的Nio程序、再然后就是关于Netty的源码分析了！欢迎关注公众号【源码学徒】 回归正题，NIO的高性能除了体现在Epoll模型之外，还有很重要的一点，就是零拷贝！首先大家要先明白一点，所
Netty学习----Java_NIO_知识点（三）
https://juejin.cn/user/4248168663101239/posts
02-01 270
NIO 与零拷贝一. NIO 与零拷贝二. 传统 IO 数据拷贝三. 传统 IO 模型四. mmap 优化五. sendFile 优化六. 零拷贝总结七. mmap 和 sendFile 的区别八. NIO零拷贝案例(比较原生IO拷贝文件速度) 一. NIO 与零拷贝 零拷贝基本介绍 零拷贝是网络编程的关键，很多性能优化都离不开。 在 Java 程序中，常用的零拷贝有 mmap(内存映射) 和 sendFile。 传统 IO 数据读写Java 传统 IO 和 网络编程的一段代码 二. 传统 IO 数
零拷贝技术
技术交流
10-24 336
1、基本概念 内核态和用户态 Linux OS 体系架构分为内核态和用户态，也叫用户空间和内核。 内核态：控制计算机的硬件资源，并提供上层应用程序运行的环境。 用户态：上层应用程序的活动空间，依托于内核提供的资源。 二者关系： 用户态（上层应用程序）通过系统调用内核态中的资源。 DMA Direct Memory Access 直接存储器访问，不依赖CPU大量中断负载。 对比流程-图源网络。 不使用DMA技术时： 使用DMA后： 使用了DMA技术后，CPU的工作量大大减轻，此时io操作已有所提升，
NIO之零拷贝
weixin_38950807的博客
06-10 566
title: Nio之零拷贝 date: 2019-06-04 08:36:01 categories: Java基础 tags: nio Linux中的内核态与用户态 如上图所示，Unix/Linux的体系架构分为内核空间（kernal space）与用户空间(application space)，内核控制着计算机的硬件资源，为上层应用程序提供运行环境。用户空间就是应用程序的活动空间，...
【4.0】NIO零拷贝浅析
无敌兔0x01
09-22 443
文章目录 一、ZERO-COPY简介 二、传统IO过程(1)读操作(2)写操作(3)总结 一、ZERO-COPY简介 一、简介：初学建议不看这里的理论？中规中矩还是要介绍一下定义的！零拷贝描述的是CPU不执行从一个存储区域拷贝数据到另一个存储区域的任务，这通常用于通过网络传输一个文件时以减少CPU周期和内存带宽。二、利处： 1、减少甚至完全避免不必要的CPU拷贝，从而让CPU解脱出来去执行其他...
认识零拷贝
CBeann的博客
01-22 399
注意事项 （1）零拷贝的含义是数据不从内核空间拷贝到用户空间，也不从用户空间拷贝到内核空间 （2）零拷贝完全依赖操作系统，操作系统提供了就是提供了，没有提供就没有提供，java本身做不了任何事情 传统的IO拷贝 需求 java读取磁盘上的文件，并且输出出去。这个过程包含两个步骤，一个是读，一个是写 图片解读 三列分别为用户空间、内核空间、硬件 (1)read() syscall...
深入理解Netty网络编程：从BIO到NIO，再到零拷贝
5.基于NIO的零拷贝： - 零拷贝技术减少CPU对数据的拷贝次数，提高传输效率。如mmap（内存映射文件）、sendfile等方法，减少内核到用户空间、用户空间到内核空间的数据复制，适用于大数据传输。 6.Netty实现简单UDP/...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值