记一次java内存溢出的解决过程

    public synchronized void merge(){
        LogUtil.info("InvertIndex merge start...");
        File f=new File(path); //这个文件是原磁盘上的索引文件
        //磁盘存在索引，合并磁盘索引和内存索引
        if (f.exists()) {
            String outPath=path+".temp";
            File outFile=new File(outPath);
            
            TreeMap<String, TreeSet<Long>> ramSnapshot=null;
            ramSnapshot=ram; //ram保存的是内存索引，这里因为ram可能被其他添加文档的线程修改，因此先存一份快照然后将ram清空，后面实际操作的是快照
            ram=new TreeMap<>();
            
            BufferedReader reader=null;
            PrintWriter writer=null;
            try {
　　　　　　　　　 //合并过程，有3个指针：分别指向内存索引的当前位置、原磁盘索引读到的位置、新的磁盘索引写入的位置
                Iterator<Entry<String, TreeSet<Long>>> ramIterator= ramSnapshot.entrySet().iterator();
                reader=new BufferedReader(new FileReader(f));
                writer=new PrintWriter(new BufferedWriter(new FileWriter(outFile)));
                
                Entry<String, TreeSet<Long>> entry=ramIterator.hasNext()?ramIterator.next():null;
                String line=reader.readLine();
                
                while (entry!=null&&line!=null) {
                    long freeRam=Runtime.getRuntime().freeMemory()/1000/1000;
                    System.out.println("freeRam: "+freeRam);
                    
                    String ramWord=entry.getKey();
                    String diskWord=line.split(separator1)[0];
                    String out="";

                    int c=ramWord.compareTo(diskWord);
　　　　　　　　　　　 //合并过程，因为是两个有序列表，采用类似归并排序的合并方法，区别在于这里如果遇到倒排词相等的时候，需要合并到一个倒排词(合并两者文档列表)
                    if (c==0) {
                        TreeSet<Long> ramDocIds=entry.getValue();
                        TreeSet<Long> diskDocIds=this.convertLine2DocIds(line);
                        TreeSet<Long> union=ramDocIds;
                        union.addAll(diskDocIds);
                        out=this.convertIndex2Line(ramWord, union);
                        
                        entry=ramIterator.hasNext()?ramIterator.next():null;
                        line=reader.readLine();
                    }else if (c<0) {
                        out=this.convertIndex2Line(ramWord, entry.getValue());
                        entry=ramIterator.hasNext()?ramIterator.next():null;
                    }else {
                        out=this.convertIndex2Line(diskWord, this.convertLine2DocIds(line));
                        line=reader.readLine();
                    }
                    
                    writer.println(out);
                }
                LogUtil.info("InvertIndex complex merge complete.");
                
                while (ramIterator.hasNext()) {
                    entry=ramIterator.next();
                    String out=this.convertIndex2Line(entry.getKey(), entry.getValue());
                    writer.println(out);
                }
                LogUtil.info("InvertIndex ram merge complete.");
                
                while ((line=reader.readLine())!=null) {
                    writer.println(line);
                }
                LogUtil.info("InvertIndex disk merge complete.");
                
            } catch (Exception e) {
                LogUtil.err("merge ram index and disk index fail.", e);
            }finally {
                try {
                    if (reader!=null) {
                        reader.close();
                    }
                    if (writer!=null) {
                        writer.close();
                    }
                } catch (Exception e2) {LogUtil.err("release resource fail.", e2);}
            }
            f.delete();
            if (!outFile.renameTo(new File(path))) {
                throw new RuntimeException("rename temp file fail.");
            }
        }else {
            //磁盘上原本不存在索引，直接将内存索引写入磁盘
            //代码略

    }