java中内存映射使用

最新推荐文章于 2024-06-03 09:14:00 发布
最新推荐文章于 2024-06-03 09:14:00 发布
阅读量963 收藏 3
点赞数 1
文章标签： java 文件内存映射 高速传输
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jinyuttt/article/details/131096914
版权

今天结合文件传输，记录一下内存映射方式读写文件，的确很快。网上都是用例子说了一下

MappedByteBuffer类的使用，其实还是那些用法，只是想把封装给大家说说。

基本用法一般给大家的代码如下：


        FileChannel fc = new RandomAccessFile("D:/TEST/test3.txt", "rw").getChannel();
        
        MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE, 0, length);
        
        for (int i = 0; i < length; i++) {
            mbb.put((byte) 'a');
        }

 FileChannel fileChannel = null;
    try {
        String filePath = "D:\\temp\\avatar.jpg";
        fileChannel = new RandomAccessFile(new File(filePath), "rw").getChannel();
        MappedByteBuffer mappedByteBuffer = fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, fileChannel.size());
        byte[] bytes = new byte[(int) fileChannel.size()];
        mappedByteBuffer.get(bytes);
        print(bytes);

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

这里先说写代码，如果我们说大文件，比如说20G的写入，则需要分段写。一次写入的数据量一定要比映射的区间小。

  /**
     * 写入
     * @param src
     * @throws IOException
     */
    public void writeFileBuffer(ByteBuffer src) throws IOException {

        if (randomAccessFile == null) {

            long curLen = fileLen - writeLen;//计算剩余的字节
            if (curLen > size) {
                curLen = size;
            }
            try {
                randomAccessFile = new RandomAccessFile(writeFile, "rw");
               // randomAccessFile.setLength(fileLen);
                FileChannel rafchannel = randomAccessFile.getChannel();
                //mmap 使得jvm堆和pageCache有一块映射空间
                MappedByteBuffer map = rafchannel.map(FileChannel.MapMode.READ_WRITE, writeLen, curLen);  // 1000M的pageCache大小
                map.put(src);
                writeMap = map;
                writeLen += src.limit();
                foceLen=src.limit();

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

            if (foceLen + src.limit() > size) {
                //重新加载
                long curLen = fileLen - writeLen;
                if (curLen > size) {
                    curLen = size;
                }
                MappedByteBuffer map = randomAccessFile.getChannel().map(FileChannel.MapMode.READ_WRITE, writeLen, curLen);  // 1000M的pageCache大小
                map.put(src);
                writeMap = map;
                writeLen += src.limit();
                foceLen = src.limit();
            } else {
                writeMap.put(src);
                foceLen += src.limit();
                writeLen += src.limit();
            }
        }

    }

如果size大小的映射空间不够类，就需要从已经写入的大小（当前文件末尾），从新映射区间，然后继续写入。文件快写完时，也不能太多，多余的就是空的，二进制文件就麻烦了。要计算刚刚好。在这里传输的时候，先通知对方传输的文件名称和大小，这样就好了。

foceLen用了记录映射区间已经使用的大小，新写入不够就重新映射。这样连续写完为止。

读取20G大文件原来一样。

  /**
     * 读取文件
     * @param path
     * @throws IOException
     */
    public void readFile(String path) throws IOException {
        randomAccessFile = new RandomAccessFile(path, "rw");
    }

    /**
     * 读取数据
     * @return
     * @throws IOException
     */
    public ByteBuffer read() throws IOException {

        if (randomAccessFile != null) {

            long pos = readNum * size;//已经读取的字节
            long leftNum = randomAccessFile.getChannel().size() - pos;//剩下字节
            readNum++;
            try {
                if (leftNum > size) {
                    MappedByteBuffer map = randomAccessFile.getChannel().map(FileChannel.MapMode.READ_ONLY, pos, size);  // 1000M的pageCache大小
                    return map.asReadOnlyBuffer();
                } else {
                    isRead=true;
                    MappedByteBuffer map = randomAccessFile.getChannel().map(FileChannel.MapMode.PRIVATE, pos, leftNum);  // 1000M的pageCache大小
                    randomAccessFile.close();//最后一次了
                    return map.asReadOnlyBuffer();
                }
            } catch (Exception ex) {
                ex.printStackTrace();
                return null;
            }
        }
        return null;
    }

每次读取size大小，我这里说1000M。最后一次读取就标记读取完了。

完整类

package MappedByteBufferFile;

import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

public class MMapBufferChanel {

    /**
     * 读写缓存
     */
    private final int size = 4096 * 1024 * 250;


    public int getSize() {
        return size;
    }

    private RandomAccessFile randomAccessFile = null;

    /**
     * 读取次数
     */
    private long readNum = 0;

   private  boolean isRead=false;
    /**
     * 写入的文件
     */
    private String writeFile;

    /**
     * 写入的
     */
    private MappedByteBuffer writeMap = null;

    /**
     * 已经写的缓存
     */
    private  long foceLen=0;

    /**
     * 写的文件长度
     */
    private long fileLen;

    /**
     * 已经写入的长度
     */
    private long writeLen = 0;

    /**
     * 读取完成
     * @return
     */
    public boolean getRead()
    {
        return  isRead;
    }

    public void setFileLen(long len) {
        this.fileLen = len;
    }


    public void setWriteFile(String file) {
        this.writeFile = file;
    }
   public  void  close() throws IOException {
       if(randomAccessFile!=null)
       {
           randomAccessFile.close();
       }
   }
    /**
     * 写入
     * @param src
     * @throws IOException
     */
    public void writeFileBuffer(ByteBuffer src) throws IOException {

        if (randomAccessFile == null) {

            long curLen = fileLen - writeLen;//计算剩余的字节
            if (curLen > size) {
                curLen = size;
            }
            try {
                randomAccessFile = new RandomAccessFile(writeFile, "rw");
               // randomAccessFile.setLength(fileLen);
                FileChannel rafchannel = randomAccessFile.getChannel();
                //mmap 使得jvm堆和pageCache有一块映射空间
                MappedByteBuffer map = rafchannel.map(FileChannel.MapMode.READ_WRITE, writeLen, curLen);  // 1000M的pageCache大小
                map.put(src);
                writeMap = map;
                writeLen += src.limit();
                foceLen=src.limit();

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

            if (foceLen + src.limit() > size) {
                //重新加载
                long curLen = fileLen - writeLen;
                if (curLen > size) {
                    curLen = size;
                }
                MappedByteBuffer map = randomAccessFile.getChannel().map(FileChannel.MapMode.READ_WRITE, writeLen, curLen);  // 1000M的pageCache大小
                map.put(src);
                writeMap = map;
                writeLen += src.limit();
                foceLen = src.limit();
            } else {
                writeMap.put(src);
                foceLen += src.limit();
                writeLen += src.limit();
            }
        }

    }


    /**
     * 读取文件
     * @param path
     * @throws IOException
     */
    public void readFile(String path) throws IOException {
        randomAccessFile = new RandomAccessFile(path, "rw");
    }

    /**
     * 读取数据
     * @return
     * @throws IOException
     */
    public ByteBuffer read() throws IOException {

        if (randomAccessFile != null) {

            long pos = readNum * size;//已经读取的字节
            long leftNum = randomAccessFile.getChannel().size() - pos;//剩下字节
            readNum++;
            try {
                if (leftNum > size) {
                    MappedByteBuffer map = randomAccessFile.getChannel().map(FileChannel.MapMode.READ_ONLY, pos, size);  // 1000M的pageCache大小
                    return map.asReadOnlyBuffer();
                } else {
                    isRead=true;
                    MappedByteBuffer map = randomAccessFile.getChannel().map(FileChannel.MapMode.PRIVATE, pos, leftNum);  // 1000M的pageCache大小
                    randomAccessFile.close();//最后一次了
                    return map.asReadOnlyBuffer();
                }
            } catch (Exception ex) {
                ex.printStackTrace();
                return null;
            }
        }
        return null;
    }
}

全部是ByteBuffer是因为我使用的是sockchannel。这里虽然读写一个类，但是使用必须是不同实例。

如果只是读取20G一瞬间。写入速度不稳，笔记本机械硬盘70M-100M.我使用的还有传输阻塞，传完就读完。传输阻塞慢，所以读取就和传输一样。如果内存足够异步读取，那就说读完很久才传输完。sock缓存设置10M，传输130M/s.

完整的代码会上传csdn.

git地址：

https://github.com/jinyuttt/MappedByteBufferFile.git

jason成都
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java 内存文件_Java内存映射文件（Memory Mapped Files）
weixin_42131352的博客
02-12 1567
Java内存映射文件(Memory Mapped Files)什么是Java内存映射文件/IO内存映射文件是一种允许Java程序直接从内存访问的特殊文件。通过将整个文件或者文件的一部分映射到内存中、操作系统负责获取页面请求和写入文件，应用程序就只需要处理内存数据，这样可以实现非常快速的IO操作。用于内存映射文件的内存在Java的堆空间以外。Java中的java.nio包支持内存映射文件，可以使用M...
Java内存映射文件（Memory Mapped Files）
weixin_34121304的博客
11-27 1782
2019独角兽企业重金招聘Python工程师标准>>> ...
Java 基础知识储备.mmap
08-02
总结了Java开发过程中常用到的基础工具、实用技能。会一直更新，有了这些工具，开发时会事半功倍。包括字符串、数组、字典、算法、加密工具等常用开发中用得到的东西。
MemMap内存映射
寂蝶难双，窃窃思羽.
08-20 544
MemMap内存映射 转载自：https://blog.csdn.net/u014630431/article/details/72844501 一、内存映射文件是由一个文件到一块内存的映射。Win32提供了允许应用程序把文件映射到一个进程的函数 (CreateFileMapping)。内存映射文件与虚拟内存有些类似，通过内存映射文件可以保留一个地址空间的区域，同时将物理存储器提交给此区域，内...
解锁 Java I/O 力量，一站式掌握文件操作、内存映射等黑科技
最新发布
w风雨无阻w的专栏
06-03 833
文件 I/O:主要由File和等类库提供支持，用于文件系统层面的操作。缓冲 I/O:通过等缓冲流类进行封装，提高I/O效率。字符 I/O家族类用于编码解码字符数据，支持跨平台操作。管道/通道 I/O则为高级I/O提供了统一抽象，支持新I/O模型。网络 I/O:由等网络编程类库组成，用于网络资源读写。对象 I/O:通过可直接序列化/反序列化对象。内存映射 I/O则提供了利用内存映射文件提高IO效率的新模式。可以看出，Java I/O 体系设计非常全面，几乎覆盖了所有常见的资源读写场景。
重新认识 Java 中的内存映射（mmap）
zhexiao
03-02 1874
恰恰和网传的很多言论相反，mmap 由于其不切态的特性，特别适合顺序读写，但由于 sun.nio.ch.FileChannelImpl#map(MapMode mode, long position, long size) 中 size 的限制，只能传递一个 int 值，所以，单次 map 单个文件的长度不能超过 2G，如果将 2G 作为文件大 or 小的阈值，那么小于 2G 的文件使用 mmap 来读写一般来说是有优势的。一个实用的技巧是动态分配的内存映射区域，在读取过后，可以异步回收掉。
Java 中的内存映射（Mmap）
qq_43695848的博客
06-21 4812
将原来普通读取文件的方式改为内存映射文件的方式。mmap 是一种内存映射文件的方法，即将一个文件映射到进程的地址空间
Java内存映射，上G大文件轻松处理
weixin_30522183的博客
08-14 1615
内存映射文件(Memory-mapped File)，指的是将一段虚拟内存逐字节映射于一个文件，使得应用程序处理文件如同访问主内存（但在真正使用到这些数据前却不会消耗物理内存，也不会有读写磁盘的操作），这要比直接文件读写快几个数量级。 稍微解释一下虚拟内存（很明显，不是物理内存），它是计算机系统内存管理的一种技术。像施了妖法一样使得应用程序认为它拥有连续的可用的内存，实际上呢，它通常是...
聊聊Java中的mmap
dyuan134的博客
04-13 511
当我们读取或修改大文件时，传统的文件I/O操作可能会变得很慢，这时候mmap就可以派上用场了。mmap（Memory-mapped files）是一种在内存中创建映射文件的机制，它可以使我们像访问内存一样访问文件，从而避免频繁的文件I/O操作。使用mmap的方式是在内存中创建一个虚拟地址，然后将文件映射到这个虚拟地址上。这个映射的过程是由操作系统完成的，它会将文件中的数据按需加载到内存中，而不是一次性加载整个文件。这样，我们可以通过指针操作这个虚拟地址，就像访问内存一样来读取或者修改文件内容。
mmap java_Java中mmap的使用
weixin_29447313的博客
02-21 2464
什么是mmapJava中mmap的使用，具体参考kafka源码中的OffsetIndex这个类操作文件，就相当于操作一个ByteBuffer一样public class TestMmap {public static String path = "C:\\Users\\64371\\Desktop\\mmap";public static void main(String[] args) thro...
Java 中的内存映射Mmap
weixin_43480441的博客
10-18 2229
Java 中原生读写方式大概可以被分为三种：普通 IO，FileChannel(文件通道)，mmap(内存映射)。区分他们也很简单，例如 FileWriter,FileReader 存在于 java.io 中，他们属于普通 IO;FileChannel 存在于 java.nio 中，也是 Java 最常用的文件操作类;而今天的主角 mmap，则是由 FileChannel 调用 map 方法衍生出来的一种特殊读写文件的方式，被称之为内存映射。
理解 MappedByteBuffer 及其实现类 DirectByteBuffer
yzh_1346983557的博客
09-04 2804
java nio (jdk1.4) 中引入了MappedByteBuffer，相比较之前java io 的BufferedReader，BufferedInputStream 操作大文件，性能得到了极大提升，下面理解一下性能得到提升的原因。 内存管理 在理解MappedByteBuffer之前，先看看计算机内存管理的几个术语： MMU：内存管理单元，CPU中独立的硬件。 物理内存：即内存条的内存空间。 虚拟内存：虚拟内存是计算机系统内存管理的一种技术。它使得应用程序认为它拥有连续可用的内存（一个连续完
JavaNIO(5)、内存映射文件
wu1308156206的博客
07-15 298
内存映射文件
Java课题笔记~ MyBatis映射文件
qq_53142796的博客
08-02 203
= sId">= sName">= sAge">
java 大文件_java读取大文件 超大文件的几种方法
weixin_35977784的博客
02-12 2039
java 读取一个巨大的文本文件既能保证内存不溢出又能保证性能import java.io.BufferedReader;import java.io.File;import java.io.FileReader;import java.io.RandomAccessFile;import java.nio.ByteBuffer;import java.nio.MappedByteBuffer;i...
Spring Boot 解决跨域Cores问题
岚殿的代码笔记
08-09 1283
import org.springframework.context.annotation.Configuration; import org.springframework.web.servlet.config.annotation.CorsRegistry; import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; @Configuration public class CorsConfig implemen.
java的Mmap二三事
薛笛的专栏
04-07 7378
    先说些题外话，Java的内存管理一直是让人又爱又恨玩意。学生时代写Java程序主要考虑的只是实现算法、完成功能，偶尔碰到OutofMemory也是递归搞成死循环。什么垃圾回收、内存管理统统交给JVM去烦恼。上班之后再用Java发现完全不是那么回事，大访问量的情况下如何减少fullgc和停顿时间，内存管理无法由程序员控制和干预、甚至无法获知究竟哪个部分用了多少内存有时着实让人有些抓狂。各位可
内存管理、内存映射mmap、java内存映射
yzh_1346983557的博客
04-12 1801
MMU：Memory Management Unit，内存管理单元，CPU中独立硬件，负责处理CPU的内存访问请求。虚拟地址到物理地址的转换（即虚拟内存管理）。物理内存：真实存在的插在主板内存槽上的内存条，提供临时储存。虚拟内存：计算机系统内存管理的一种技术。它使得应用程序认为它拥有连续可用的内存（一个连续完整的地址空间），而实际上物理内存通常被分隔成多个内存碎片，还有部分暂时存储在外部磁盘存储器上，在需要时进行数据交换。页面文件：操作系统反映构建并使用虚拟内存的硬盘空间大小而创建的文件。
Java 内存映射读取文件_Java内存映射 大文件轻松处理|chu
weixin_39726131的博客
02-16 419
前言内存映射文件(Memory-mapped File)，指的是将一段虚拟内存逐字节映射于一个文件，使得应用程序处理文件如同访问主内存(但在真正使用到这些数据前却不会消耗物理内存，也不会有读写磁盘的操作)，这要比直接文件读写快几个数量级。稍微解释一下虚拟内存(很明显，不是物理内存)，它是计算机系统内存管理的一种技术。像施了妖法一样使得应用程序认为它拥有连续的可用的内存，实际上呢，它通常是被分隔成多...
java内存映射读读取
05-18
Java提供了内存映射文件（MappedByteBuffer）的API，可以将一个文件映射到内存中，然后直接在内存中读写文件数据，这样可以大大提高文件的读写效率。 以下是一个简单的Java内存映射文件读取的示例代码： ```java import java.io.IOException; import java.io.RandomAccessFile; import java.nio.MappedByteBuffer; import java.nio.channels.FileChannel; public class MemoryMappedFileReader { public static void main(String[] args) throws IOException { RandomAccessFile file = new RandomAccessFile("test.txt", "r"); FileChannel channel = file.getChannel(); long fileSize = channel.size(); MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_ONLY, 0, fileSize); for (int i = 0; i < fileSize; i++) { System.out.print((char) buffer.get()); } channel.close(); file.close(); } } ``` 这个程序读取了一个名为“test.txt”的文件，并将其映射到内存中。然后，它通过MappedByteBuffer来读取文件数据，并将其打印到控制台上。最后，程序关闭了文件通道和文件对象。 需要注意的是，MappedByteBuffer只能用于读取文件数据，不能用于写入文件数据。如果需要写入文件数据，可以使用MappedByteBuffer的子类DirectByteBuffer，或者使用NIO的其他API。此外，需要保证文件的大小不超过Integer.MAX_VALUE，否则会抛出IllegalArgumentException异常。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值