JAVA IO专题二：java NIO读取文件并通过socket发送，最少拷贝了几次？堆外内存和所谓的零拷贝到底是什么关系

相关IO专题

JAVA IO专题一：java InputStream和OutputStream读取文件并通过socket发送，到底涉及几次拷贝
JAVA IO专题二：java NIO读取文件并通过socket发送，最少拷贝了几次？堆外内存和所谓的零拷贝到底是什么关系
JAVA IO专题三：java的内存映射和应用场景
JAVA IO专题四：java顺序IO原理以及对应的应用场景

内核的零拷贝

内核的零拷贝，指的是不需要消耗CPU资源，完全交给DMA来处理，内核空间的数据没有多余的拷贝。主要经历了这么几个发展历程：

一、传统的read + send

1、先调用操作系统的read函数，由DMA将文件拷贝到内核，然后CPU把内核数据拷贝到用户缓冲区（堆外内存）
2、调用操作系统的send函数，由CPU把用户缓冲区的数据拷贝到socket缓冲区，最后DMA把socket缓冲区数据拷贝到网卡进行发送。

这个过程中内核数据拷贝到用户空间，用户空间又拷贝回内存，有两次多余的拷贝。

二、sendfile初始版本

直接调用sendfile来发送文件，流程如下：
1、首先通过 DMA将数据从磁盘读取到内核
2、然后通过 CPU将数据从内核拷贝到socket缓冲区
3、最终通过 DMA将socket缓冲区数据拷贝到网卡发送

sendfile 与 read + send 方式相比，少了一次 CPU的拷贝。但是从上述过程中也可以发现从内核缓冲区拷贝到socket缓冲区是没必要的。

三、sendfile改进版本，真正的零拷贝

内核为2.4或者以上版本的linux系统上，改进后的处理过程如下：
1、DMA 将磁盘数据拷贝到内核缓冲区，向socket缓冲区中追加当前要发送的数据在内核缓冲区中的位置和偏移量
2、DMA gather copy 根据 socket缓冲区中的位置和偏移量，直接将内核缓冲区中的数据拷贝到网卡上。
经过上述过程，数据只经过了 2 次 copy 就从磁盘传送出去了。并且没有CPU的参与。

java的零拷贝

一、利用directBuffer

在上一篇文章JAVA IO专题一：java InputStream和OutputStream读取文件并通过socket发送，到底涉及几次拷贝中，我们提到了基于BIO读取文件发送消息，一共涉及六次拷贝，其中堆外和堆内内存的拷贝是多余的，我们可以利用directBuffer来减少这两次拷贝：

//打开文件通道
FileChannel fileChannel = FileChannel.open(Paths.get("/test.txt"));
//申请堆外内存
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(1024);
//读取到堆外内存
fileChannel.read(byteBuffer);
//打开socket通道
SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("localhost", 9099));
//堆外内存写入socket通道
socketChannel.write(byteBuffer);

每一行代码都有清楚的注释，我们主要来看一下fileChannel.read、socketChannel.write做了什么：

  • fileChannel.read 分析
//FileChannelImpl
public int read(ByteBuffer dst) throws IOException {
    ... 忽略了一堆不重要代码
        synchronized (positionLock) {
            int n = 0;
            int ti = -1;
            try {
                do {
                   // 调用IOUtil，根据文件描述符fd读取数据到直接缓冲区dst中
                    n = IOUtil.read(fd, dst, -1, nd);
                } while ((n == IOStatus.INTERRUPTED) && isOpen());
                return IOStatus.normalize(n);
            } finally {
                threads.remove(ti);
                end(n > 0);
                assert IOStatus.check(n);
            }
        }
    }
//IOUtil
static int read(FileDescriptor fd, ByteBuffer dst, long position,
                    NativeDispatcher nd)
        throws IOException
    {
        ByteBuffer bb = Util.getTemporaryDirectBuffer(dst.remaining());
        try {
            int n = readIntoNativeBuffer(fd, bb, position, nd);
            bb.flip();
            if (n > 0)
                dst.put(bb);
            return n;
        } finally {
            Util.offerFirstTemporaryDirectBuffer(bb);
        }
    }

private static int readIntoNativeBuffer(FileDescriptor fd, ByteBuffer bb,
                                            long position, NativeDispatcher nd)
        throws IOException
    {
        int pos = bb.position();
        int lim = bb.limit();
        assert (pos <= lim);
        int rem = (pos <= lim ? lim - pos : 0);

        if (rem == 0)
            return 0;
        int n = 0;
        if (position != -1) {
            n = nd.pread(fd, ((DirectBuffer)bb).address() + pos,
                         rem, position);
        } else {
           //第一次读取会走到这里，否则走上面的分支
            n = nd.read(fd, ((DirectBuffer)bb).address() + pos, rem);
        }
        if (n > 0)
            bb.position(pos + n);
        return n;
    }
//FileDispatcherImpl
 int read(FileDescriptor fd, long address, int len) throws IOException {
        return read0(fd, address, len);
    }

这里的调用链比较深，我们一步一步梳理：

  1. 调用fileChannel.read实际是走到了FileChannelImpl.read方法，然后走到n = IOUtil.read(fd, dst, -1, nd);调用IOUtil的read，传入了文件描述符、directBuffer
  2. IOUtil 调用自己的readIntoNativeBuffer方法，字面意思是讲数据读取到native缓存，即堆外内存
  3. IOUtil 的 readIntoNativeBuffer 方法调用n = nd.read(fd, ((DirectBuffer)bb).address() + pos, rem);，即NativeDispatcher 的read方法，传入文件描述符，堆外内存地址以及要读取的长度
  4. 这里的 NativeDispatcher 实现类为 FileDispatcherImpl，实际调用的是native方法read0，并传入了文件描述符、堆外内存地址和读取长度

我们简单看一下native的read0方法做了什么：

// 以下内容来自于 jdk/src/solairs/native/sun/nio/ch/FileDispatcherImpl.c

JNIEXPORT jint JNICALL
Java_sun_nio_ch_FileDispatcherImpl_read0(JNIEnv *env, jclass clazz,
                             jobject fdo, jlong address, jint len)
{
    //拿到文件描述符
    jint fd = fdval(env, fdo);
    //根据地址拿到堆外内存的指针
    void *buf = (void *)jlong_to_ptr(address);
  //直接调用系统函数read把文件描述符读取到buf中
    return convertReturnVal(env, read(fd, buf, len), JNI_TRUE);
}

可以看到native的read0方法是直接调用系统函数read，根据jvm传过来的堆外内存地址，将文件数据读取到堆外内存中（read方法的作用在内核零拷贝小节里已经提到了）。即直接操作堆外内存，而不使用DirectByteBuffer的时候，还需要将堆外内存拷贝到堆内进行读写JAVA IO专题一：java InputStream和OutputStream读取文件并通过socket发送，到底涉及几次拷贝），因此使用堆外内存+channel的方式，可以避免堆内外内存拷贝，一定程度上也能提高效率。

  • socketChannel.write 分析
//SocketChannelImpl.java
  public int write(ByteBuffer buf) throws IOException {
        synchronized (writeLock) {
              ... 忽略不重要代码
            int n = 0;
            try {
                for (;;) {
                    //调用IOUtil.write写数据
                    n = IOUtil.write(fd, buf, -1, nd);
                    if ((n == IOStatus.INTERRUPTED) && isOpen())
                        continue;
                    return IOStatus.normalize(n);
                }
            } finally {
                writerCleanup();
            }
        }
    }
//IOUtil.java
static int write(FileDescriptor fd, ByteBuffer src, long position,
                     NativeDispatcher nd)
        throws IOException
    {
        if (src instanceof DirectBuffer)
             //directBuffer直接走这里
            return writeFromNativeBuffer(fd, src, position, nd);
    }

  private static int writeFromNativeBuffer(FileDescriptor fd, ByteBuffer bb,
                                             long position, NativeDispatcher nd) throws IOException
    {
        int pos = bb.position();
        int lim = bb.limit();
        assert (pos <= lim);
        int rem = (pos <= lim ? lim - pos : 0);

        int written = 0;
        if (rem == 0)
            return 0;
        if (position != -1) {
            written = nd.pwrite(fd,
                                ((DirectBuffer)bb).address() + pos,
                                rem, position);
        } else {
            //调用SocketDispatcher写数据
            written = nd.write(fd, ((DirectBuffer)bb).address() + pos, rem);
        }
        if (written > 0)
            bb.position(pos + written);
        return written;
    }

//SocketDispatcher.java
int write(FileDescriptor fd, long address, int len) throws IOException {
        //直接调用了FileDispatcherImpl的native方法write0
        return FileDispatcherImpl.write0(fd, address, len);
    }

在看native方法之前还是先做简单的梳理：

  1. socketChannel.write 实际调用了SocketChannelImpl.write，然后调用IOUtil.write(fd, buf, -1, nd); 传入文件描述符和堆外内存引用
  2. IOUtil.write调用自己的私有方法 writeFromNativeBuffer，内部调用了written = nd.write(fd, ((DirectBuffer)bb).address() + pos, rem);，将文件描述符、堆外内存地址交给了NativeDispatcher
  3. 此处的NativeDispatcher实际是 SocketDispatcher，里面直接调用了FileDispatcherImpl.write0(fd, address, len);native方法

接着跟踪FileDispatcherImpl.write0(fd, address, len);这个native方法：

// 以下内容来自于 jdk/src/solairs/native/sun/nio/ch/FileDispatcherImpl.c

JNIEXPORT jint JNICALL
Java_sun_nio_ch_FileDispatcherImpl_write0(JNIEnv *env, jclass clazz,
                              jobject fdo, jlong address, jint len)
{
    //转换文件描述符
    jint fd = fdval(env, fdo);
    //转换为堆外内存指针
    void *buf = (void *)jlong_to_ptr(address);
    //直接调用系统函数write将堆外内存数据发送出去
    return convertReturnVal(env, write(fd, buf, len), JNI_FALSE);
}

可以看到native的write0方法是直接调用系统函数write将堆外内存数据发送出去（write方法的作用在内核零拷贝小节里已经提到了）。

  • 小结
    fileChannel和socketChannel配合directBuffer，本质上区别不大，都是配合系统函数write和read对文件描述符，直接操作堆外内存。因此相比较于BIO可以省去两次拷贝。
二、channel.transferTo

java中的零拷贝就是依赖操作系统的sendfile函数来实现的，提供了channel.transferTo方法，允许将一个channel的数据直接发送到另一个channel，接下来我们通过示例代码和具体的源码来分析和验证前面的说法。
示例代码如下：

//打开socketChannel
SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("localhost", 9099));
//
FileChannel fileChannel = FileChannel.open(Paths.get("/test.txt"));
fileChannel.transferTo(0, fileChannel.size(), socketChannel);

只用了一行代码fileChannel.transferTo(0, fileChannel.size(), socketChannel);就把文件数据写到了socket，继续看源码：

//FileChannelImpl.java
public long transferTo(long position, long count,
                           WritableByteChannel target)
        throws IOException
    {
         ... 忽略不重要代码
        long sz = size();
        if (position > sz)
            return 0;
        int icount = (int)Math.min(count, Integer.MAX_VALUE);
        if ((sz - position) < icount)
            icount = (int)(sz - position);

        long n;
          //先尝试直接tranfer，如果内核支持的话
        if ((n = transferToDirectly(position, icount, target)) >= 0)
            return n;
        //尝试mappedTransfer，只适用于受信任的channel类型
        if ((n = transferToTrustedChannel(position, icount, target)) >= 0)
            return n;
          //channel不受信任的话，会走最慢的方式
        return transferToArbitraryChannel(position, icount, target);
    }

// FileChannelimpl.java
private long transferToDirectly(long position, int icount,
                                    WritableByteChannel target)
        throws IOException
    {
        if (!transferSupported)
            //系统不支持就直接返回
            return IOStatus.UNSUPPORTED;

        FileDescriptor targetFD = null;
        if (target instanceof FileChannelImpl) { //如果目标是fileChannel则走这里
            if (!fileSupported)
                return IOStatus.UNSUPPORTED_CASE;
            targetFD = ((FileChannelImpl)target).fd;
        } else if (target instanceof SelChImpl) { 
            //SocketChannel实现了SelChImpl接口，因此会走这里
            if ((target instanceof SinkChannelImpl) && !pipeSupported)
                return IOStatus.UNSUPPORTED_CASE;
            //给targetFD赋值
            targetFD = ((SelChImpl)target).getFD();
        }
        if (targetFD == null)
            return IOStatus.UNSUPPORTED;
        //将fileChannel和socketChannel对应的fd转换为具体的值
        int thisFDVal = IOUtil.fdVal(fd);
        int targetFDVal = IOUtil.fdVal(targetFD);
        //不支持自己给自己传输
        if (thisFDVal == targetFDVal) 
            return IOStatus.UNSUPPORTED;

        long n = -1;
        int ti = -1;
        try {
            begin();
            ti = threads.add();
            if (!isOpen())
                return -1;
            do { 
                //调用native方法transferTo0
                n = transferTo0(thisFDVal, position, icount, targetFDVal);
            } while ((n == IOStatus.INTERRUPTED) && isOpen());
            if (n == IOStatus.UNSUPPORTED_CASE) {
                if (target instanceof SinkChannelImpl)
                    pipeSupported = false;
                if (target instanceof FileChannelImpl)
                    fileSupported = false;
                return IOStatus.UNSUPPORTED_CASE;
            }
            if (n == IOStatus.UNSUPPORTED) {
                // Don't bother trying again
                transferSupported = false;
                return IOStatus.UNSUPPORTED;
            }
            return IOStatus.normalize(n);
        } finally {
            threads.remove(ti);
            end (n > -1);
        }
    }

代码有点长：

  1. 调用FileChannelImpl的transferTo，会尝试三种情况，如果系统支持零拷贝，则走 transferToDirectly
  2. transferToDirectly 方法前面做了各种判断，其实可以理解为直接调用了n = transferTo0(thisFDVal, position, icount, targetFDVal);native方法

再来跟踪transferTo0：

// 以下内容来自于 jdk/src/solairs/native/sun/nio/ch/FileChannelImpl.c
JNIEXPORT jlong JNICALL
Java_sun_nio_ch_FileChannelImpl_transferTo0(JNIEnv *env, jobject this,
                                            jint srcFD,
                                            jlong position, jlong count,
                                            jint dstFD)
{
#if defined(__linux__)
    off64_t offset = (off64_t)position;
    //直接调用sendfile
    jlong n = sendfile64(dstFD, srcFD, &offset, (size_t)count);
    if (n < 0) {
        if (errno == EAGAIN)
            return IOS_UNAVAILABLE;
        if ((errno == EINVAL) && ((ssize_t)count >= 0))
            return IOS_UNSUPPORTED_CASE;
        if (errno == EINTR) {
            return IOS_INTERRUPTED;
        }
        JNU_ThrowIOExceptionWithLastError(env, "Transfer failed");
        return IOS_THROWN;
    }
    return n;
}

这个方法里其实有linux、solaris、APPLE等多个平台的实现，这里只截取linux下的实现，可以看到是直接调用了系统函数sendfile来实现的数据发送，具体的拷贝次数则要看linux内核的版本了。

总结

  • NIO读取文件并通过socket发送，最少拷贝几次？
    直接调用channel.transferTo，同时linux内核版本大于等于2.4，则可以将拷贝次数降低到2次，并且CPU不参与拷贝。
  • 堆外内存和所谓的零拷贝到底是什么关系
    笔者理解网上说的零拷贝，可以理解为内核层面的零拷贝和java层面的零拷贝，所谓的0并不是一次拷贝都没有，而是在不同的场景下尽可能减少拷贝次数。

参考文章

Java 堆外内存、零拷贝、直接内存以及针对于NIO中的FileChannel的思考
JavaIO原理剖析之 网络IO

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
禁止转载，如需转载请通过简信或评论联系作者。
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 203,362评论 5赞 477
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,330评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 150,247评论 0赞 337
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,560评论 1赞 273
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,580评论 5赞 365
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,569评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,929评论 3赞 395
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,587评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,840评论 1赞 297
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,596评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,678评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,366评论 4赞 318
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,945评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,929评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,165评论 1赞 259
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 43,271评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,403评论 2赞 342

推荐阅读更多精彩内容

  • 深入理解NIO零拷贝及用户空间与内核空间切换
    1、什么是零拷贝 维基上是这么描述零拷贝的：零拷贝描述的是CPU不执行拷贝数据从一个存储区域到另一个存储区域的任务...
    爱学习的蹭蹭阅读 4,960评论 0赞 20
  • 零拷贝，NIO，Reactor和Netty
    1. NIO 阅读本节前，请先阅读我的NIO基础文章：https://www.jianshu.com/nb/878...
    伊凡的一天阅读 1,772评论 0赞 21
  • 家长会谈合作
    久违的晴天，家长会。 家长大会开好到教室时，离放学已经没多少时间了。班主任说已经安排了三个家长分享经验。 放学铃声...
    飘雪儿5阅读 7,474评论 16赞 22
  • 2019－11－28 周四 阴
    今天感恩节哎，感谢一直在我身边的亲朋好友。感恩相遇！感恩不离不弃。 中午开了第一次的党会，身份的转变要...
    迷月闪星情阅读 10,548评论 0赞 11
  • 赵原野传 国家
    可爱进取，孤独成精。努力飞翔，天堂翱翔。战争美好，孤独进取。胆大飞翔，成就辉煌。努力进取，遥望，和谐家园。可爱游走...
    赵原野阅读 2,713评论 1赞 1