java - 多线程字符串处理因#threads 而爆炸

Question

我正在处理一个多线程项目，我们必须将文件中的一些文本解析为一个魔法对象，对该对象进行一些处理，然后聚合输出。旧版本的代码在一个线程中解析文本，并使用 Java 的 ExecutorService 在线程池中进行对象处理。 .我们没有获得我们想要的性能提升，事实证明，相对于每个对象的处理时间，解析花费的时间比我们想象的要长，所以我尝试将解析移到工作线程中。

这应该行得通，但实际发生的是每个对象的时间作为池中线程数的函数爆炸。它比线性差，但不如指数差。

我已将其缩减为一个小示例(无论如何在我的机器上)显示该行为。该示例甚至没有创建魔法对象；它只是在进行字符串操作。我看不到线程间的依赖关系；我知道split()效率不是很高，但我无法想象为什么它会在多线程环境中拉屎。我错过了什么吗？

我在 24 核机器上运行 Java 7。行很长，每行约 1MB。 features中可以有几十个项目，以及 edges 中的 10 万多个项目.

示例输入:

1    1    156    24    230    1350    id(foo):id(bar):w(house,pos):w(house,neg)    1->2:1@1.0    16->121:2@1.0,3@0.5

运行 16 个工作线程的示例命令行:

$ java -Xmx10G Foo 16 myfile.txt

示例代码:

public class Foo implements Runnable {
String line;
int id;
public Foo(String line, int id) {
    this.line = line;
    this.id = id;
}
public void run() {
    System.out.println(System.currentTimeMillis()+" Job start "+this.id);
    // line format: tab delimited                                                                
    // x[4]
    // graph[2]
    // features[m]      <-- ':' delimited                                              
    // edges[n]
    String[] x = this.line.split("\t",5);
    String[] graph = x[4].split("\t",4);
    String[] features = graph[2].split(":");
    String[] edges = graph[3].split("\t");
    for (String e : edges) {
        String[] ee = e.split(":",2);
        ee[0].split("->",2);
        for (String f : ee[1].split(",")) {
            f.split("@",2);
        }
    }                                                                    
    System.out.println(System.currentTimeMillis()+" Job done "+this.id);
}
public static void main(String[] args) throws IOException,InterruptedException {
    System.err.println("Reading from "+args[1]+" in "+args[0]+" threads...");
    LineNumberReader reader = new LineNumberReader(new FileReader(args[1]));
    ExecutorService pool = Executors.newFixedThreadPool(Integer.parseInt(args[0]));
    for(String line; (line=reader.readLine()) != null;) {
        pool.submit(new Foo(line, reader.getLineNumber()));
    }
    pool.shutdown();
    pool.awaitTermination(7,TimeUnit.DAYS);
}
}

---

更新:

• 首先将整个文件读入内存没有效果。更具体地说，我阅读了整个文件，将每一行添加到 ArrayList<String> 中。 .然后我遍历列表以创建池的作业。这使得子串吃堆假设不太可能，不是吗？
• 编译一份分隔符模式副本以供所有工作线程使用没有任何效果。 :(

---

解决方案:

我已将解析代码转换为使用基于 indexOf() 的自定义拆分例程，像这样:

private String[] split(String string, char delim) {
    if (string.length() == 0) return new String[0];
    int nitems=1;
    for (int i=0; i<string.length(); i++) {
        if (string.charAt(i) == delim) nitems++;
    }
    String[] items = new String[nitems];
    int last=0;
    for (int next=last,i=0; i<items.length && next!=-1; last=next+1,i++) {
        next=string.indexOf(delim,last);
        items[i]=next<0?string.substring(last):string.substring(last,next);
    }
    return items;       
}

奇怪的是，随着线程数量的增加，这不会崩溃，我不知道为什么。不过这是一个功能性的解决方法，所以我会接受它...

Answer 1

在 Java 7 中，String.split() 在内部使用 String.subString()，出于“优化”的原因，它不会创建真正的新 Strings，但空 String 外壳指向原始外壳的子部分。

因此，当您将 split() 一个 String 分成小块时，原始的(可能很大)仍在内存中，最终可能会吃掉所有的堆。我看到您解析大文件，这可能存在风险(这已在 Java 8 中更改)。

鉴于您的格式众所周知，我建议“手动”解析每一行，而不是使用 String.split()(正则表达式对性能来说确实很糟糕)，并创建真正的新的子部分。