Question

我有一个程序从文件中读取大量序列，并在该列表中的所有对中进行计算。然后它将所有这些计算存储到一个哈希集中。当运行该程序大约一半时，我得到GC开销限制错误。

我意识到这是因为垃圾收集器占用了98％的计算时间，甚至无法恢复2％的堆。这是我的代码：

ArrayList<String> c = loadSequences("file.txt"); // Loads 60 char DNA sequences
HashSet<DNAPair,Double> LSA = new HashSet<DNAPair,Double>(); 
for(int i = 0; i < c.size(); i++) {
    for(int j = i+1; j < c.size(); j++) {
        LSA.put(new DNAPair(c.get(i),c.get(j)),localSeqAlignmentSimilarity(c.get(i),c.get(j)));
    }
}

以下是实际方法的代码：

public static double localSeqAlignmentSimilarity(String s1, String s2) {
    s1 = " " + s1;
    s2 = " " + s2;
    int max = 0,h = 0,maxI = 0,maxJ = 0;

    int[][] score = new int[61][61];
    int[][] pointers = new int[61][61];

    for(int i = 1; i < s1.length(); i++) {
        pointers[i][0] = 2;
    }
    for(int i = 1; i < s2.length(); i++) {
        pointers[0][i] = 1;
    }

    boolean inGap = false;
    for(int i = 1; i < s1.length(); i++) {
        for(int j = 1; j < s2.length();  j++) {
            h = -99;
            if(score[i-1][j-1] + match(s1.charAt(i),s2.charAt(j)) > h) {
                h = score[i-1][j-1] + match(s1.charAt(i),s2.charAt(j));
                pointers[i][j] = 3;
                inGap = false;
            } 
            if(!inGap) {
                if(score[i-1][j] + GAPPENALTY > h) {
                    h = score[i-1][j] + GAPPENALTY;
                    pointers[i][j] = 2;
                    inGap = true;
                } 
                if(score[i][j-1] + GAPPENALTY > h) {
                    h = score[i][j-1] + GAPPENALTY;
                    pointers[i][j] = 1;
                    inGap = true;
                }
            } else {
                if(score[i-1][j] + GAPEXTENSION > h) {
                    h = score[i-1][j] + GAPEXTENSION;
                    pointers[i][j] = 2;
                    inGap = true;
                } 
                if(score[i][j-1] + GAPEXTENSION > h) {
                    h = score[i][j-1] + GAPEXTENSION;
                    pointers[i][j] = 1;
                    inGap = true;
                }
            }

            if(0 > h) h = 0;

            score[i][j] = h;
            if(h >= max) {
                max = h;
                maxI = i;
                maxJ = j;
            }
        }
    }

    double matches = 0;
    String o1 = "",  o2 = "";
    while(!(maxI == 0 && maxJ == 0)) {
        if(pointers[maxI][maxJ] == 3) {
            o1 += s1.charAt(maxI);
            o2 += s2.charAt(maxJ);
            maxI--;
            maxJ--;
        } else if(pointers[maxI][maxJ] == 2) {
            o1 += s1.charAt(maxI);
            o2 += "_";
            maxI--;
        } else if(pointers[maxI][maxJ] == 1) {
            o1 += "_";
            o2 += s2.charAt(maxJ);
            maxJ--;
        }
    }

    StringBuilder a = new StringBuilder(o1);
    b = new StringBuilder(o2);
    o1 = a.reverse().toString();
    o2 = b.reverse().toString();
    a.setLength(0);
    b.setLength(0);

    for(int i = 0; i < Math.min(o1.length(), o2.length()); i++) {
        if(o1.charAt(i) == o2.charAt(i)) matches++;
    }
    return matches/Math.min(o1.length(), o2.length());
}

我认为这是因为我在方法中声明的所有变量（两个int数组和stringbuilders等）每次运行方法时都会创建越来越多的对象，所以我将它们全部更改为静态字段并清除他们每次（例如Arrays.fill（得分，0）;）而不是创建一个新对象。

然而，这根本没有帮助，我仍然遇到同样的错误。

存储所有计算的hashset是否变得太大而且无法由java存储？我没有得到堆空间错误，所以看起来有点奇怪。

我还更改了命令行参数，为JVM提供了更多空间，但这似乎没有帮助。

对此问题的任何见解都会有所帮助。谢谢！

Answer 1

这是一个问题，如果c.size（）是73657并且序列是唯一的：

HashSet<DNAPair,Double> LSA = new HashSet<DNAPair,Double>(); 
 for(int i = 0; i < c.size(); i++) {
   for(int j = i+1; j < c.size(); j++) {
      LSA.put(...);
   }
 }

假设这些是唯一序列，您基本上是为每对添加一个元素到LSA。你提到你有70k的序列，所以你将有70k * 70k = ~50亿对，每个都需要最少4个字节来存储，这意味着你需要至少分配20+ GB才能是可行的。

Answer 2

是的，确实可能是数据量太大而无法存储在内存中。我首先尝试使用类似JConsole的内容或通常从程序中读取MemoryMXBean来实际分析程序的内存使用情况。

如果它有用，我编写了一个小的Classmexer代理，它允许您从Java程序中查询Java对象（和子对象）的实际内存使用情况。

顺便说一句，尝试“愚弄”或抢占JVM的内存管理系统通常是不合理的，例如将对象设置为静态，这实际上不应该是静态的。

java.lang.OutOfMemoryError：GC开销限制

2 个答案: