Java 字符串内存泄漏

Question

我不是java专家。

我的代码正在将文件读入String。此代码每 5 分钟执行一次。 文件的大小各不相同。有时是 100 行，有时是 1000 行。

几天后，我经历了“内存不足”。

我的问题是，当我的代码超出读取文件函数的范围时，Java垃圾收集字符串吗？

我在互联网上阅读很困惑。有人说它不会被删除并使用StringBuffer。

// Demonstrate FileReader.

import java.io.*;
class FileReaderDemo {
    public static void read(BufferedReader br) throws Exception {
        long length = 0;
        String s;
        while (true) {
            s = br.readLine();
            s += "abcd";
            if (s == null) {
                break;
            }
            length += s.length();
            //System.out.println(s);
        }
        System.out.println("Read: " + (length / 1024 / 1024) + " MB");
    }

    public static void main(String args[]) throws Exception {
        //FileReader fr = new FileReader("FileReaderDemo.java");
        FileReader fr = new FileReader("big_file.txt.1");
        BufferedReader br = new BufferedReader(fr);
        String s;
        read(br);
        fr = new FileReader("big_file.txt.1");
        br = new BufferedReader(fr);
        read(br);
        fr = new FileReader("big_file.txt.1");
        br = new BufferedReader(fr);
        read(br);
        fr = new FileReader("big_file.txt.1");
        br = new BufferedReader(fr);
        read(br);
        BufferedReader in = new BufferedReader(new InputStreamReader(System. in )); in .readLine();
        fr.close();
    }
}

Answer 1

您好，我不是java专家。

每个人都有可以学习的东西。

我的代码正在将文件读入字符串中，该代码每 5 分钟执行一次。现在有时文件大小为 100 行，有时为 1000 行。

听起来不是很大，也不是很频繁。应该不是问题。

几天后，我遇到了“内存不足”的情况。

您应该能够获得堆转储并查看内存不足的位置以及原因。

我的问题是，当我的代码超出读取文件功能的范围时。 Java 垃圾是否收集 String 。

当不再可以通过强引用访问它时，可以收集它。

我在网上读到一些人说它不会被删除并使用 StringBuffer ，这让我很困惑

听起来很困惑，听起来你来对地方了。我从来没有听说过这个。

Answer 2

您的 read 方法永远不会终止。一旦到达文件末尾，您只需继续将字符串 "nullabcd" 添加到 s 即可，永远如此。

编辑：忘记了，s 每次都会重新分配。尽管如此，我还是看不出你的 read 方法如何终止。

Answer 3

您发布的代码不会泄漏内存。但是，while (true) 循环永远不会终止，因为在测试时s 永远不会是null。

---

让我们对其进行一些更改以使其“工作”。

    public static void read(BufferedReader br) throws Exception {
            long length = 0;
            String s = "";
            while (true) {
                    String ss = br.readLine();
                    if (ss == null) {
                            break;
                    }
                    s += ss;
                    length += ss.length();
            }
            System.out.println("Read: " + (length/1024/1024) + " MB");
    }

这段代码也不会泄漏内存，因为当方法返回时（如果不是之前），在方法中创建的字符串都将成为垃圾回收的候选者。

每次执行 s += ss; 时，都会创建一个新字符串，其中包含当前 s 中的所有字符以及 ss 中的字符。假设有 N 行平均包含 L 个字符，则 s += ss; 语句将被调用 N 次，将创建 N 个字符串，并平均复制 (N * L) ^2 / 2 个字符。

---

然而，创建StringBuilder有一个很好的理由，那就是减少字符串分配和字符复制的数量。让我们重写该方法以使用 StringBuilder；即替换不同步的StringBuffer。

    public static void read(BufferedReader br) throws Exception {
            long length = 0;
            StringBuilder sb = new StringBuilder(sb);
            while (true) {
                    String ss = br.readLine();
                    if (ss == null) {
                            break;
                    }
                    sb.append(ss);
                    length += ss.length();
            }
            System.out.println("Read: " + (length/1024/1024) + " MB");
    }

此版本将重新分配 StringBuilder 的内部字符数组最多 log2(N) 次并复制最多 2 * N * L< /code> 字符。

---

总结 - 使用 StringBuilder 是一个好主意，但不是因为内存泄漏。如果存在内存泄漏，它不在原始示例代码或修复版本中。

Answer 4

像下面这样更改程序以消耗更少的内存。内存消耗的一个巨大来源是由于您重复的字符串连接 s += "abcd"; - 避免这种情况，您可能会减少一半以上的内存消耗（未经测试 - 如果您自己分析一下）你想知道）。

public static void read(BufferedReader br) throws Exception {

    long length = 0;
    //String s; <--- change to the line below
    StringBuilder sb = new StringBuilder();
    while (true) {
        String s = br.readLine();
        if (s == null) {
            break;
        }
        //s += "abcd";  <--- change to the line below
        sb.append(s).append("abcd");
        length += s.length();
        //System.out.println(s);
    }
    System.out.println("Read: " + (length / 1024 / 1024) + " MB");
}

Answer 5

正如其他人指出的那样，这段代码永远不会终止。您发布的代码似乎不是您遇到问题的原始代码。

在没有看到实际代码的情况下很难诊断，但是一旦没有从代码的其他部分引用字符串，它们肯定会被垃圾收集。

大胆猜测：使用完 Readers 和 InputStreams 后，您是否会调用 close() ？如果没有，这可能是内存不足错误的原因。