java – 多线程字符串处理用#threads炸毁

2024年1月19日 216次阅读

我正在开发一个多线程项目,我们必须将文件中的一些文本解析为魔术对象,对对象进行一些处理,然后聚合输出.旧版本的代码在一个线程中解析了文本,并使用
Java的ExecutorService在线程池中进行了对象处理.我们没有得到我们想要的性能提升,并且结果是解析花费的时间比我们想象的相对于每个对象的处理时间要长,所以我尝试将解析移动到工作线程中.

这本来应该有效,但实际发生的是每个对象的时间随着池中线程数的增加而爆炸.它比线性更糟糕,但不如指数那么糟糕.

我把它简化为一个小例子(无论如何在我的机器上)显示行为.该示例甚至没有创建魔术对象;它只是在进行字符串操作.我可以看到没有线程间的依赖关系;我知道split()并不是非常有效但我无法想象为什么它会在多线程环境中使用它.我错过了什么吗？

我在24核机器上运行Java 7.线条很长,每条约1MB.功能中可以有许多项目,边缘可以有100k项目.

样本输入：

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;       
}

奇怪的是,随着线程数量的增加,这并没有爆发,我不知道为什么.这是一个功能性的解决方法,所以我会忍受它……

最佳答案 在Java 7中,String.split()在内部使用String.subString(),出于“优化”的原因,它不会创建真正的新字符串,而是指向原始字符串子节的空String shell.

因此,当你将一个String分割成一小块时,原始的一个(可能是巨大的)仍然在内存中,最终可能会占用你所有的堆.我看到你解析大文件,这可能是一个风险(这在Java 8中已经改变).

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

点赞