调试 Java 内存不足错误

Question

我仍然是一个相对较新的程序员，我在 Java 中一直遇到的一个问题是内存不足错误。我不想使用 -Xmx 增加内存，因为我觉得错误是由于编程不当造成的，我想改进我的编码而不是依赖更多内存。

我所做的工作涉及处理大量文本文件，压缩后每个文件大小约为 1GB。我这里的代码旨在循环遍历正在删除新压缩文本文件的目录。它打开第二个最新的文本文件（不是最新的，因为仍在写入），并使用 Jsoup 库解析文本文件中的某些字段（字段用自定义分隔符分隔：“|nTa|”指定一个新列，“|nLa|”指定一个新行）。

我觉得应该没有理由使用大量内存。我打开一个文件，扫描它，解析相关位，将解析后的版本写入另一个文件，关闭该文件，然后移至下一个文件。我不需要将整个文件存储在内存中，当然也不需要将已经处理过的文件存储在内存中。

当我开始解析第二个文件时出现错误，这表明我没有处理垃圾收集。请看一下代码，看看您是否能发现我正在做的事情，这意味着我使用了比应有的更多的内存。我想学习如何正确地做到这一点，这样我就不再出现记忆错误了！

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
import java.util.TreeMap;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;

import org.jsoup.Jsoup;

public class ParseHTML {

    public static int commentExtractField = 3;
    public static int contentExtractField = 4;
    public static int descriptionField = 5;

    public static void main(String[] args) throws Exception {

        File directoryCompleted = null;     
        File filesCompleted[] = null;

        while(true) {

            // find second most recent file in completed directory  
            directoryCompleted = new File(args[0]);     
            filesCompleted = directoryCompleted.listFiles();

            if (filesCompleted.length > 1) {

                TreeMap<Long, File> timeStamps = new TreeMap<Long, File>(Collections.reverseOrder());

                for (File f : filesCompleted) {
                    timeStamps.put(getTimestamp(f), f);
                }

                File fileToProcess = null;

                int counter = 0;

                for (Long l : timeStamps.keySet()) {
                    fileToProcess = timeStamps.get(l);
                    if (counter == 1) {
                        break;
                    }
                    counter++;
                }   

                // start processing file
                GZIPInputStream gzipInputStream = null;

                if (fileToProcess != null) {
                    gzipInputStream = new GZIPInputStream(new FileInputStream(fileToProcess));
                }

                else {
                    System.err.println("No file to process!");
                    System.exit(1);
                }

                Scanner scanner = new Scanner(gzipInputStream);
                scanner.useDelimiter("\\|nLa\\|");

                GZIPOutputStream output = new GZIPOutputStream(new FileOutputStream("parsed/" + fileToProcess.getName()));

                while (scanner.hasNext()) {
                    Scanner scanner2 = new Scanner(scanner.next()); 
                    scanner2.useDelimiter("\\|nTa\\|");

                    ArrayList<String> row = new ArrayList<String>();

                    while(scanner2.hasNext()) {
                        row.add(scanner2.next());   
                    }

                    for (int index = 0; index < row.size(); index++) {
                        if (index == commentExtractField ||
                                index == contentExtractField ||
                                index == descriptionField) {
                            output.write(jsoupParse(row.get(index)).getBytes("UTF-8"));
                        }

                        else {
                            output.write(row.get(index).getBytes("UTF-8"));
                        }   

                        String delimiter = "";

                        if (index == row.size() - 1) {
                            delimiter = "|nLa|";
                        }

                        else {
                            delimiter = "|nTa|";
                        }

                        output.write(delimiter.getBytes("UTF-8"));
                    }
                }

                output.finish();
                output.close();
                scanner.close();
                gzipInputStream.close();


            }
        }
    }

    public static Long getTimestamp(File f) {
        String name = f.getName();
        String removeExt = name.substring(0, name.length() - 3);
        String timestamp = removeExt.substring(7, removeExt.length());
        return Long.parseLong(timestamp);
    }

    public static String jsoupParse(String s) {
        if (s.length() == 4) {
            return s;
        }

        else {
            return Jsoup.parse(s).text();
        }
    }
}

如何确保当我完成对象时，它们被销毁并且不使用任何资源？例如，每次关闭 GZIPInputStream、GZIPOutputStream 和 Scanner 时，如何确保它们被完全销毁？

根据记录，我收到的错误是：

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
at java.util.Arrays.copyOf(Arrays.java:2882)
at java.lang.AbstractStringBuilder.expandCapacity(AbstractStringBuilder.java:100)
at java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:572)
at java.lang.StringBuilder.append(StringBuilder.java:203)
at org.jsoup.parser.TokeniserState$47.read(TokeniserState.java:1171)
at org.jsoup.parser.Tokeniser.read(Tokeniser.java:42)
at org.jsoup.parser.TreeBuilder.runParser(TreeBuilder.java:101)
at org.jsoup.parser.TreeBuilder.parse(TreeBuilder.java:53)
at org.jsoup.parser.Parser.parse(Parser.java:24)
at org.jsoup.Jsoup.parse(Jsoup.java:44)
at ParseHTML.jsoupParse(ParseHTML.java:125)
at ParseHTML.main(ParseHTML.java:81)

Answer 1

我没有花很长时间分析您的代码（没有什么突出的），但是一个好的通用目的开始是熟悉免费的 VisualVM 工具。 这是一个合理的使用指南，尽管还有更多文章。

在我看来，有更好的商业分析器 - JProfiler 就是其中之一 - 但它至少会向您显示大多数内存被分配给哪些对象/类，以及可能导致这种情况发生的方法堆栈跟踪。更简单地说，它显示了一段时间内的堆分配情况，您可以使用它来判断是否无法清除某些内容或者它是否是不可避免的峰值。

我建议这样做，而不是查看代码的细节，因为这是一种有用的诊断技能。

Answer 2

更新：此问题已在 JSoup 1.6.2 中修复。

在我看来，这可能是您正在使用的 JSoup 解析器中的一个错误...目前 JSoup.parse() 的文档有一个警告“BETA：如果您确实引发了异常，或者错误的解析树，请提交一个 漏洞。”这表明他们并不确信它在生产代码中使用是完全安全的。

我还发现了几个提到内存不足异常的错误报告，其中一个表明这是由于解析由 JSoup 静态保存的错误对象，并且从 JSoup 1.6.1 降级到 1.5.2 可能是一种解决方法。

Answer 3

我想知道您的解析是否失败是因为您解析了错误的 HTML（例如未闭合的标签、不成对的引号或诸如此类的东西）？您可以执行输出 /println 来查看您在文档中的进展情况（如果有的话）。在内存耗尽之前，Java 库可能无法理解文档/文件的结尾。

解析
public static Document parse(String html) 将 HTML 解析为文档。由于未指定基本 URI，因此绝对 URL 检测依赖于包含标签的 HTML。

http://jsoup.org/apidocs/org/jsoup /Jsoup.html#parse(java.lang.String)

Answer 4

很难说清楚发生了什么，但我想到了两件事。

1）在一些奇怪的情况下（取决于输入文件），以下循环可能会将整个文件加载到内存中：

while(scanner2.hasNext()) {
    row.add(scanner2.next());
}

2）通过查看 stackTrace 似乎 jsoupParse 是问题所在。我相信这一行 Jsoup.parse(s).text(); 首先将 s 加载到内存中，并取决于字符串大小（这又取决于特定的文件输入）这可能会导致 OutOfMemoryError

也许上述两点的组合就是问题所在。同样，仅通过查看代码很难判断。

同一个文件是否总是发生这种情况？你检查一下输入的内容和其中的自定义分隔符吗？

Answer 5

假设问题不在 JSoup 代码中，我们可以做一些内存优化。例如，ArrayListrow 可以被剥离，因为它在内存中保存所有已解析的行，但解析只需要一行。

删除了 row 的内部循环：

//Caution! May contain obvious bugs!
while (scanner.hasNext()) {
    String scanStr = scanner.next();

    //manually count of rows to replace 'row.size()'
    int rowCount = 0;
    int offset = 0;
    while ((offset = scanStr.indexOf("|nTa|", offset)) >= 0) {
        rowCount++;
        offset++;
    }
    rowCount++;

    Scanner scanner2 = new Scanner(scanStr);
    scanner2.useDelimiter("\\|nTa\\|");

    int index = 0;
    while (scanner2.hasNext()) {
        String curRow = scanner2.next();

        if (index == commentExtractField
               || index == contentExtractField
               || index == descriptionField) {
            output.write(jsoupParse(curRow).getBytes("UTF-8"));
        } else {
            output.write(curRow.getBytes("UTF-8"));
        }

        String delimiter = "";
        if (index == rowCount - 1) {
            delimiter = "|nLa|";
        } else {
            delimiter = "|nTa|";
        }

        output.write(delimiter.getBytes("UTF-8"));
    }
}