• MappedByteBuffer的映射内存的释放


    原文链接:https://blog.csdn.net/wujumei1962/article/details/42919383

    MappedByteBuffer的内存释放,主要由垃圾回收引起的。

    首先,来看一下Oracle的bug list,这是一个无法修复的bug,所以在使用MappedByteBuffer的时候一定要注意内存的释放。

    第一个case是:

    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.nio.MappedByteBuffer;
    import java.nio.channels.FileChannel;
     
    public class FileDelete {
     
        public static void main(String[] args) {
            FileInputStream fis = null;
            File f = new File("a.txt");
            try {
                fis = new FileInputStream(f);
                FileChannel fc = fis.getChannel();
     
                // 把文件映射到内存
                MappedByteBuffer bb = fc.map(FileChannel.MapMode.READ_ONLY, 0,
                        (int) fc.size());
     
                // TODO
     
                fc.close();
                fis.close();
            } catch (FileNotFoundException ex) {
                System.err.println("Error! " + ex.getMessage());
                System.exit(2);
            } catch (IOException e) {
                System.err.println("Error! " + e.getMessage());
                System.exit(3);
            }
     
            // 删除文件
            boolean deleted = f.delete();
            if (!(deleted)) {
                System.err.println("Could not delete file " + f.getName());
            }
        }
     
    }

    删除文件失败!原因是没有释放内存。

    第二个case是:

    import java.io.File;
    import java.io.RandomAccessFile;
    import java.nio.MappedByteBuffer;
    import java.nio.channels.FileChannel;
     
    public class TestMemoryMapping {
        public static void main(String[] args) {
            try {
                File f = File.createTempFile("Test", null);
                f.deleteOnExit();
                RandomAccessFile raf = new RandomAccessFile(f, "rw");
                raf.setLength(1024);
                FileChannel channel = raf.getChannel();
                MappedByteBuffer buffer = channel.map(
                        FileChannel.MapMode.READ_WRITE, 0, 1024);
                channel.close();
                raf.close();
                 buffer = null;
    //             System.gc();
                if (f.delete())
                    System.out.println("Temporary file deleted: " + f);
                else
                    System.err.println("Not yet deleted: " + f);
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }

    将buffer引用设为null,还是失败。我们都知道,垃圾回收器不保证立即回收垃圾,是不可靠的。添加注释掉的代码
    System.gc();
    会显示的进行垃圾回收,但是同样地,这是没法保证的。我在本机上运行了10000次,失败了五六次。
    究其原因,FileChannel在调用了map方法,进行内存映射得到MappedByteBuffer,但是没有提供unmap方法(),释放内存。事实上,unmap方法是在FileChannelImpl类里实现的,是个私有方法。在finalize延迟的时候,unmap方法无法调用,在删除文件的时候就会因为内存未释放而失败。不过可以通过显示的调用unmap方法来释放内存。 

    import java.io.File;
    import java.io.RandomAccessFile;
    import java.lang.reflect.Method;
    import java.nio.MappedByteBuffer;
    import java.nio.channels.FileChannel;
     
    import sun.nio.ch.FileChannelImpl;
     
    public class TestMemoryMapping {
        public static void main(String[] args) {
            try {
                File f = File.createTempFile("Test", null);
                f.deleteOnExit();
                RandomAccessFile raf = new RandomAccessFile(f, "rw");
                raf.setLength(1024);
                FileChannel channel = raf.getChannel();
                MappedByteBuffer buffer = channel.map(
                        FileChannel.MapMode.READ_WRITE, 0, 1024);
                channel.close();
                raf.close();
                // 加上这几行代码,手动unmap
                Method m = FileChannelImpl.class.getDeclaredMethod("unmap",
                        MappedByteBuffer.class);
                m.setAccessible(true);
                m.invoke(FileChannelImpl.class, buffer);
                if (f.delete())
                    System.out.println("Temporary file deleted: " + f);
                else
                    System.err.println("Not yet deleted: " + f);
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }

    则可以保证,成功释放内存

    在别的地方也找到类似的处理方法,不过是让buffer本身来释放内存

    AccessController.doPrivileged(new PrivilegedAction() {
      public Object run() {
        try {
          Method getCleanerMethod = buffer.getClass().getMethod("cleaner", new Class[0]);
          getCleanerMethod.setAccessible(true);
          sun.misc.Cleaner cleaner = (sun.misc.Cleaner) 
          getCleanerMethod.invoke(byteBuffer, new Object[0]);
          cleaner.clean();
        } catch (Exception e) {
          e.printStackTrace();
        }
        return null;
      }
    });

    其实两种方法都是了Cleaner类的,clean方法。
    我们从FileChannelImpl的unmap方法来入手

    private static void unmap(MappedByteBuffer bb) {
    Cleaner cl = ((DirectBuffer)bb).cleaner();
    if (cl != null)
    cl.clean();
    }
    这是一个私有方法,调用了Cleaner的clean方法来释放内存,所以我们也可以直接在代码里使用以上代码来释放内存。

    ____________________________________________________________________________________________

    1.RandomAccessFile特点

      RandomAccessFile是java Io体系中功能最丰富的文件内容访问类。即可以读取文件内容,也可以向文件中写入内容。但是和其他输入/输入流不同的是,程序可以直接跳到文件的任意位置来读写数据。 
      因为RandomAccessFile可以自由访问文件的任意位置,所以如果我们希望只访问文件的部分内容,那就可以使用RandomAccessFile类。 
      与OutputStearm,Writer等输出流不同的是,RandomAccessFile类允许自由定位文件记录指针,所以RandomAccessFile可以不从文件开始的地方进行输出,所以RandomAccessFile可以向已存在的文件后追加内容。则应该使用RandomAccessFile。

    2.RandomAccessFile的整体介绍

       RandomAccessFile类包含了一个记录指针,用以标识当前读写处的位置,当程序新创建一个RandomAccessFile对象时,该对象的文件记录指针位于文件头(也就是0处),当读/写了n个字节后,文件记录指针将会向后移动n个字节。除此之外,RandomAccessFile可以自由的移动记录指针,即可以向前移动,也可以向后移动。RandomAccessFile包含了以下两个方法来操作文件的记录指针.

    • long getFilePointer(); 返回文件记录指针的当前位置
    • void seek(long pos); 将文件记录指针定位到pos位置

    RandomAccessFile即可以读文件,也可以写,所以它即包含了完全类似于InputStream的3个read()方法,其用法和InputStream的3个read()方法完全一样;也包含了完全类似于OutputStream的3个write()方法,其用法和OutputStream的3个Writer()方法完全一样。除此之外,RandomAccessFile还包含了一系类的readXXX()和writeXXX()方法来完成输入和输出。

    RandomAccessFile有两个构造器,其实这两个构造器基本相同,只是指定文件的形式不同而已,一个使用String参数来指定文件名,一个使用File参数来指定文件本身。除此之外,创建RandomAccessFile对象还需要指定一个mode参数。该参数指定RandomAccessFile的访问模式,有以下4个值:

    • “r” 以只读方式来打开指定文件夹。如果试图对该RandomAccessFile执行写入方法,都将抛出IOException异常。
    • “rw” 以读,写方式打开指定文件。如果该文件尚不存在,则试图创建该文件。
    • “rws” 以读,写方式打开指定文件。相对于”rw” 模式,还要求对文件内容或元数据的每个更新都同步写入到底层设备。
    • “rwd” 以读,写方式打开指定文件。相对于”rw” 模式,还要求对文件内容每个更新都同步写入到底层设备。

    3.使用RandomAccessFile实现从指定位置读取文件的功能

    复制代码
     1 public  static void main(String[] args)throws IOException {
     2         String filePath="E:\\learnproject\\Iotest\\lib\\src\\main\\java\\com\\Test.txt";
     3         RandomAccessFile raf=null;
     4         File file=null;
     5         try {
     6             file=new File(filePath);
     7             raf=new RandomAccessFile(file,"r");
     8             // 获取 RandomAccessFile对象文件指针的位置,初始位置为0
     9             System.out.print("输入内容:"+raf.getFilePointer());
    10             //移动文件记录指针的位置
    11             raf.seek(1000);
    12 
    13             byte[] b=new byte[1024];
    14             int hasRead=0;
    15             //循环读取文件
    16             while((hasRead=raf.read(b))>0){
    17                 //输出文件读取的内容
    18                 System.out.print(new String(b,0,hasRead));
    19             }
    20         }catch (IOException e){
    21             e.printStackTrace();
    22         }finally {
    23             raf.close();
    24         }
    25     }
    复制代码

    在上面的程序的关键代码两处,一处是创建了RandomAccessFile对象,该对象以只读模式打开了Test.txt文件,这意味着RandomAccessFile文件只能读取文件内容,不能执行写入。第二处调用了seek(1000)方法,是指把文件的记录指针定位到1000字节的位置。也就是说程序将从1000字节开始读取数据。其他部分的代码的读取方式和其他的输入流没有区别。

    4.使用RandomAccessFile实现向文件中追加内容的功能

    复制代码
    public class RandomAccessFileTest2 {
        public  static void main(String[] args)throws IOException {
            String filePath="E:\\learnproject\\Iotest\\lib\\src\\main\\java\\com\\Test.txt";
            RandomAccessFile raf=null;
            File file=null;
            try {
                file=new File(filePath);
                // 以读写的方式打开一个RandomAccessFile对象
                raf=new RandomAccessFile(file,"rw");
                //将记录指针移动到该文件的最后
                raf.seek(raf.length());
                //向文件末尾追加内容
                raf.writeChars("这是追加内容。。");
            }catch (IOException e){
                e.printStackTrace();
            }finally {
                raf.close();
            }
        }
    复制代码

    上面代码先以读,写方式创建了一个RandomAccessFile对象,然后将文件记录指针移动到最后,接下来使用RandomAccessFile向文件中写入内容。和其他输出例OutputStream的方式相同。每运行一次上面的程序,就能发现text.txt文件中多添加了一行内容。

    5.使用RandomAccessFile实现向文件指定位置插入内容的功能

    注:RandomAccessFile不能向文件的指定位置插入内容,如果直接将文件记录指针移动到中间某位置后开始输出,则新输出的内容会覆盖文件原有的内容,如果需要向指定位置插入内容,程序需要先把插入点后面的内容写入缓存区,等把需要插入的数据写入到文件后,再将缓存区的内容追加到文件后面。

    复制代码
    /**
     * 插入文件指定位置的指定内容
     * @param filePath 文件路径
     * @param pos  插入文件的指定位置
     * @param insertContent 插入文件中的内容
     * @throws IOException
     */
      public static void insert(String filePath,long pos,String insertContent)throws IOException{
          RandomAccessFile raf=null;
          File tmp=File.createTempFile("tmp",null);
          tmp.deleteOnExit();
          try {
              // 以读写的方式打开一个RandomAccessFile对象
              raf = new RandomAccessFile(new File(filePath), "rw");
              //创建一个临时文件来保存插入点后的数据
              FileOutputStream fileOutputStream = new FileOutputStream(tmp);
              FileInputStream fileInputStream = new FileInputStream(tmp);
              //把文件记录指针定位到pos位置
              raf.seek(pos);
              raf.seek(pos);
              //------下面代码将插入点后的内容读入临时文件中保存-----
              byte[] bbuf = new byte[64];
              //用于保存实际读取的字节数据
              int hasRead = 0;
              //使用循环读取插入点后的数据
              while ((hasRead = raf.read(bbuf)) != -1) {
                  //将读取的内容写入临时文件
                  fileOutputStream.write(bbuf, 0, hasRead);
              }
              //-----下面代码用于插入内容 -----
              //把文件记录指针重新定位到pos位置
              raf.seek(pos);
              //追加需要插入的内容
              raf.write(insertContent.getBytes());
              //追加临时文件中的内容
              while ((hasRead = fileInputStream.read(bbuf)) != -1) {
                  //将读取的内容写入临时文件
                  raf.write(bbuf, 0, hasRead);
              }
          }catch (Exception e){
              throw  e;
          }
      }
        public  static void main(String[] args)throws IOException {
            String filePath="E:\\learnproject\\Iotest\\lib\\src\\main\\java\\com\\Test.txt";
            insert(filePath,1000,"插入指定位置指定内容");
        }
    复制代码

    上面的程序使用File类的createTempFile方法创建了一个临时文件(该文件将在JVM退出后被删除),用于保存被插入点后面的内容。程序先将文件中插入点后的内容读入临时文件中,然后重新定位到插入点,将需要插入的内容添加到文件后面,最后将临时文件的内容添加到文件后面,通过这个过程就可以向指定文件,指定位置插入内容。每次运行上面的程序,都会看到Test.txt文件中多了一行内容。

    (转:https://blog.csdn.net/nightcurtis/article/details/51384126)

    只有当你忍痛前行后,你猜能知道,所谓的痛不过尔尔!

    ________________________________________________________________________________________________

    java类库大全

    https://www.sxt.cn/io/randomaccessfile_setlength.html

    ___________________________________________________________________________________________________

    Java.io.File中的delete()方法和deleteOnExit()方法的区别

     

    1.delete()方法:

                当调用delete()方法时,直接删除文件,不管该文件是否存在,一经调用立即执行;

    2.deleteOnExit()方法:

               当调用deleteOnExit()方法时,只是相当于对deleteOnExit()作一个声明,当程序运行结束,JVM终止时才真正调用deleteOnExit()方法实现删除操作。即该方法是将删除的命令缓存了一下,到服务停止的时候再进行操作!

    示例:

     @Test
     public void test() throws IOException

    {
            File file=new File("E:"+File.separator+"filetest"+File.separatorChar+"HelloFile.txt");
            if(file.exists()){
                    file.deleteOnExit();
                    file.createNewFile();
           }
           else{
               logger.info("不存在该文件");
                 }

    }

    测试结果:在相应的位置HelloFile.txt 不存在(被删除掉了);因为此处的deleteOnExit()是在JVM退出的时候才执行的,因此相当于是先调用了createNewFile()再调用deleteOnExit();

    @Test
     public void test() throws IOException

    {
            File file=new File("E:"+File.separator+"filetest"+File.separatorChar+"HelloFile.txt");
            if(file.exists()){
                      file.delete();
                      file.createNewFile();
           }
           else{
               logger.info("不存在该文件");
                 }

    }

    测试结果:在相应的位置HelloFile.txt 仍存在(被删除掉后又建立一个新的该文件);因为此处先调用了delete()再调用createNewFile()

     
    分类: JAVA
    标签: deleteOnExitjava删除delete 
  • 相关阅读:
    接口开发总结
    python多线程的坑
    ImageMagick 安装 window10与错误总结
    中文时间转换数字时间
    postgresql数据库中~和like和ilike的区别
    pdfplumber库解析pdf格式
    网络基础-数据通信过程
    渗透测试思路总述
    网络基础-OSI七层模型
    网络基础-常用网络测试工具
  • 原文地址:https://www.cnblogs.com/kelelipeng/p/15640415.html
Copyright © 2020-2023  润新知