禅与计算机
sharkchili
2024-09-30
目录

聊聊java零拷贝的几种实现

# 写在文章开头

在之前的文章中，笔者对零拷贝技术进行了比较详细的介绍，而本文将基于之前文章的理论，从java的视角演示一下零拷贝技术的实现和技术内幕，希望对你有帮助。

Hi，我是 sharkChili ，是个不断在硬核技术上作死的技术人，是 CSDN的博客专家 ，也是开源项目 Java Guide 的维护者之一，熟悉 Java 也会一点 Go ，偶尔也会在 C源码 边缘徘徊。写过很多有意思的技术博客，也还在研究并输出技术的路上，希望我的文章对你有帮助，非常欢迎你关注我的公众号： 写代码的SharkChili 。

因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注 “加群” 即可和笔者和笔者的朋友们进行深入交流。

# 详解java中mmap+write技术的实现

# mmap+write映射写

经过上文的介绍我们就可以聊聊java对于零拷贝的实现，按照上述我们所说mmap+write技术，Java的实现也沿袭了这套理念，只不过在细节实现上有所区别，在建立直接内存映射时，Java是通过在jvm堆内存中建立directByteBuffer通过该实例记录非堆内存也就是内核缓冲区的地址和长度， 如此一来，我们后续在java程序上执行的读写操作也就会直接映射在内核缓冲区：

对此我们给出下面这段代码示例，可以看到我们拿到一个具备读写权限的FileChannel之后，通过map方法拿到物理文件在内核缓冲区的地址，直接通过put操作即可实现数据写入，整个过程上下文切换还是两次，但是却没有出现数据拷贝过程，因为我们通过map函数得到的内核缓冲区的映射地址，所有操作都会直接映射到内核缓冲区：

private static void writeToFileByMmap() {
        if (!FileUtil.exist(FILE_NAME)) {
            FileUtil.touch(FILE_NAME);
        }
        //最终写入的文件地址
        Path path = Paths.get(FILE_NAME);

        //写入内容
        //声明权限为读写和覆盖权限的文件通道
        try (FileChannel fileChannel = FileChannel.open(path, StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING)) {
            //获取写入到文件内容的字节
            byte[] bytes = "通过mmap技术实现零拷贝".getBytes(CharsetUtil.UTF_8);
            //调用map将内核缓冲区(page cache从磁盘加载文件数据) 映射到MappedByteBuffer实例
            MappedByteBuffer mappedByteBuffer = fileChannel.map(READ_WRITE, 0, bytes.length);
            if (ObjUtil.isNotNull(mappedByteBuffer)) {
                //将数据写入映射地址
                mappedByteBuffer.put(bytes);
                //强制刷到本地
                mappedByteBuffer.force();
            }


        } catch (Exception e) {
            e.printStackTrace();
        }


    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# mmap映射读

同理我们也给出mmap读数据的代码示例，读者可自行参阅：

private static void readDataByMmap() {
        //读取数据的字节
        byte[] bytes = new byte[CONTENT.getBytes().length];
        //创建一个具备读权限的文件通道
        try (FileChannel fileChannel = FileChannel.open(Paths.get(FILE_NAME), StandardOpenOption.READ)) {

            MappedByteBuffer mappedByteBuffer = fileChannel.map(READ_ONLY, 0, bytes.length);
            mappedByteBuffer.get(bytes);
            System.out.println(new String(bytes, CharsetUtil.UTF_8));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

# java中mmap方法的实现细节

如上图所表述，查看map方法内部实现，我们即可看到该方法本质就是调用native方法map0为文件分配一块虚拟内存作为文件的映射区域，然后返回这个内核映射区的起始地址，基于这个地址java程序会为其创建内存映射实例Unmapper，然后将Unmapper和内核缓冲区地址等信息直接封装为directByteBuffer，后续我们针对directByteBuffer的操作都会直接影响到映射的内核缓冲区数据。

这里我们也给出map的源码详情，核心步骤如笔者所述，读者可自行参阅：

public MappedByteBuffer map(MapMode mode, long position, long size)
        throws IOException
    {
       //......

       		
            try {
                //通过入参得文件在内核缓冲区的地址
                addr = map0(imode, mapPosition, mapSize);
            } catch (OutOfMemoryError x) {
                //......
            }

           //基于地址addr创建内存映射实例Unmapper 
            Unmapper um = new Unmapper(addr, mapSize, isize, mfd);
            //通过反射将其封装为MappedByteBuffer，其底层就是创建directByteBuffer
            if ((!writable) || (imode == MAP_RO)) {
                return Util.newMappedByteBufferR(isize,
                                                 addr + pagePosition,
                                                 mfd,
                                                 um);
            } else {
                return Util.newMappedByteBuffer(isize,
                                                addr + pagePosition,
                                                mfd,
                                                um);
            }
        } finally {
            threads.remove(ti);
            end(IOStatus.checkAll(addr));
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

我们不妨更进一步查看map0的实现，因为该实现是个native方法，所以笔者通过jdk源码包的native/sun/nio/ch/FileChannelImpl.c得到这块代码实现，可以看到其内部最核心的逻辑就是调用mmap64完成用户缓冲区和内核缓冲区的地址映射，随后将映射地址mapAddress返回给java进程，后续JVM堆内存(用户缓冲区)即直接基于这个地址操作对应的内核缓冲区数据：

对此我们也给出这段源码的核心代码段和注释：

JNIEXPORT jlong JNICALL
Java_sun_nio_ch_FileChannelImpl_map0(JNIEnv *env, jobject this,
                                     jint prot, jlong off, jlong len)
{
    //调用c内核函数mmap64获取文件
    mapAddress = mmap64(
        0,                    /* Let OS decide location */
        len,                  /* Number of bytes to map */
        protections,          /* File permissions */
        flags,                /* Changes are shared */
        fd,                   /* File descriptor of mapped file */
        off);                 /* Offset into file */

  	//......
	//返回内核缓冲区映射地址
    return ((jlong) (unsigned long) mapAddress);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

后续我们的put操作，就是通过ix方法拿到上一步所得到的地址调用copyFromArray完成数据写入：

public ByteBuffer put(byte[] src, int offset, int length) {

       			//......
       			//通过ix得到地址，然后通过copyFromArray将长度为length的src数据写入
                Bits.copyFromArray(src, arrayBaseOffset, offset << 0,
                                   ix(pos), length << 0);
            position(pos + length);
        } else {
            super.put(src, offset, length);
        }
        return this;



    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 详解java中sendfile的实现

FileChannel是用于文件读写操作的通道，它支持并发操作线程安全，通过java的FileChannel 实例的transferTo方法即实现通道与通道之间的数据传输(其底层就是调用sendfile内核函数)，从而实现本地数据传输只需将数据从磁盘加载到页缓存，后直接写入到目标文件的页缓存地址，由此减少了切态和用户态到内核态的拷贝开销。 完成上述写入操作后，操作系统就会将目标文件的脏页缓存写入磁盘中：

对应的我们给出相应的代码示例，可以看到笔者通过RandomAccessFile创建源文件和目标文件通道，通过transferFrom方法将fromChannel 数据写入到toChannel ，而transferFrom的底层实现也就是我们所说的sendfile，下面的这段示例笔者创建两个具备读写权限的文件的channel，再通过transferFrom将fromChannel 的数据写入到toChannel 中：

private static void transferFrom() {

        try (FileChannel fromChannel = new RandomAccessFile(from, "rw").getChannel();
             FileChannel toChannel = new RandomAccessFile(to, "rw").getChannel()) {

            toChannel.transferFrom(fromChannel, 0, fromChannel.size());

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
1
2
3
4
5
6
7
8
9
10
11

对应的我们也给出transferTo的底层核心实现，可以看到其内部进行文件拷贝操作流程如下：

  1. 优先尝试transferToDirectly方法，其底层就会调用内核sendfile函数(针对Linux系统)。
  2. 步骤1尝试失败，则通过调用transferToTrustedChannel尝试通过mmap+write完成写入。
  3. 步骤2也不支持，就采用传统IO方式，也就是将数据拷贝到内核缓冲区的页缓存，完成后拷贝到JVM堆内存，然后从JVM堆内存写回页缓存最后写入磁盘空间，这种方式涉及多次拷贝，所以文件传输性能表现最差。
 public long transferTo(long position, long count,
                           WritableByteChannel target)
        throws IOException
    {
        //......
		//尝试sendfile调用(针对Linux系统)
        // Attempt a direct transfer, if the kernel supports it
        if ((n = transferToDirectly(position, icount, target)) >= 0)
            return n;
		//尝试mmap+write
        // Attempt a mapped transfer, but only to trusted channel types
        if ((n = transferToTrustedChannel(position, icount, target)) >= 0)
            return n;
		//使用传统IO拷贝
        // Slow path for untrusted targets
        return transferToArbitraryChannel(position, icount, target);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

这里我们着重的说明调用1的实现，我们步入transferToDirectly可以看到其内部拿到两个文件的描述符的值之后直接调用transferTo0开始数据传输了：

private long transferToDirectly(long position, int icount,
                                    WritableByteChannel target)
        throws IOException
    {
      	//......
        int thisFDVal = IOUtil.fdVal(fd);
        int targetFDVal = IOUtil.fdVal(targetFD);
       //......

        long n = -1;
        int ti = -1;
        try {
          //......
            do {
            	//基于源和目标文件描述符的值进行文件传输
                n = transferTo0(thisFDVal, position, icount, targetFDVal);
            } while ((n == IOStatus.INTERRUPTED) && isOpen());
            if (n == IOStatus.UNSUPPORTED_CASE) {
              	//......
            }
           	//......
            return IOStatus.normalize(n);
        } finally {
          	//......
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

最终上述参数就会来到native调用的c代码，该代码位于native/sun/nio/ch/FileChannelImpl.c ，我们可以非常直观的看到上述的调用就是通过sendfile64完成零拷贝的：

JNIEXPORT jlong JNICALL
Java_sun_nio_ch_FileChannelImpl_transferTo0(JNIEnv *env, jobject this,
                                            jobject srcFDO,
                                            jlong position, jlong count,
                                            jobject dstFDO)
{
	//获取JVM传入的参数
    jint srcFD = fdval(env, srcFDO);
    jint dstFD = fdval(env, dstFDO);

#if defined(__linux__)
    off64_t offset = (off64_t)position;
    //调用sendfile完成文件传输
    jlong n = sendfile64(dstFD, srcFD, &offset, (size_t)count);
    return n;
//......
#endif
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 小结

自此我们从java开发的角度介绍了，Java这门语言对于零拷贝的使用，希望对你有帮助。

我是 sharkchili ，CSDN Java 领域博客专家，mini-redis的作者，我想写一些有意思的东西，希望对你有帮助，如果你想实时收到我写的硬核的文章也欢迎你关注我的公众号： 写代码的SharkChili 。 因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注 “加群” 即可和笔者和笔者的朋友们进行深入交流。

# 参考

【Java】Java中的零拷贝 :https://www.cnblogs.com/shanml/p/16756395.html (opens new window)

Java 两种zero-copy零拷贝技术mmap和sendfile的介绍:https://blog.csdn.net/djdjdxieuej/article/details/128683165 (opens new window)

Java NIO - 零拷贝实现:https://pdai.tech/md/java/io/java-io-nio-zerocopy.html#filechannel (opens new window)

Java 零拷贝底层原理之SendFile底层原理:https://zhuanlan.zhihu.com/p/392695792 (opens new window)

从 Linux 内核角度探秘 JDK MappedByteBuffer :https://mp.weixin.qq.com/s?__biz=Mzg2MzU3Mjc3Ng==&mid=2247489304&idx=1&sn=18e905f573906ecff411ebdcf9c1a9c5&chksm=ce77d15ff9005849b022e4288e793e5036bda42916591a4a3d28f76554188c25cfbd35d951f9&scene=178&cur_album_id=2486138956225757185#rd (opens new window)

编辑 (opens new window)
上次更新: 2026/03/26, 01:05:31
为什么流不关闭会导致内存泄漏
Java8流式编程入门

← Java8流式编程入门→

最近更新
01
基于EasyExcel实现高效导出
03-25
02
从开源框架中学习那些实用的位运算技巧
03-25
03
浅谈分布式架构设计思想和常见优化手段
03-25
更多文章>
Theme by Vdoing | Copyright © 2025-2026 Evan Xu | MIT License | 桂ICP备2024034950号 | 桂公网安备45142202000030
×
×