Java FixedThreadPool线程数和运行时

我编写了一个简单的工具，用于检查一些xml（解组和内容分析）的内容，并为每个xml编写一个日志文件

我必须用大约2MB/文件检查1000多个文件。因此，进展需要一些时间。因为我的文件之间没有依赖关系，所以我尝试在不同的线程中进行工作（没有同步的方法）

不幸的是，我的服务似乎有问题。我尝试使用fixedthreadpool执行器服务。但是具有1个线程和100个线程的运行时几乎不一样（以及cpu使用情况）。只有在每个文件（files.size）使用1个线程的情况下，cpu使用率才会高得多（约90%），运行时大约是原始运行时的10%

我不明白为什么1个线程的运行时和cpu使用率与100个线程相同

package mycode;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class Starter {

public static void main(String[] args) {
    File config = new File(args[0]);
    Starter starter = new Starter(); 
    starter.work(config);
}

private void work(File config)
{
    Long start = System.currentTimeMillis();
    ConfigReader cr = new ConfigReader(config);
    cr.init();
    FileFinder ff = new FileFinder();
    List<File>files = ff.findfiles(cr.getParam("xmlfolder"));
    List<String>done = new ArrayList<String>();


    ExecutorService es = Executors.newFixedThreadPool(Integer.parseInt(cr.getParam("max.threadcount")));
    for (File aktuell : files)
    {
        es.execute(new Threadstarter(aktuell, cr.getParam("logoutput"), done)); 
    }



    es.shutdown();


    try {
        es.awaitTermination(Long.MAX_VALUE, TimeUnit.MINUTES);

    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    Long end = System.currentTimeMillis(); 
    BufferedWriter logwriter; 
    try {
        logwriter = new BufferedWriter(new FileWriter(new File(cr.getParam("logoutput")).getAbsolutePath()+"/log.log"));
        for (String temp : done)
        {
            logwriter.write(temp);
            logwriter.newLine();
        }
        logwriter.write("Die Verarbeitung dauerte "+(end-start)/1000 +" Sekunden");
        logwriter.newLine();
        logwriter.write("Es wurden "+files.size()+" Dienststellen verarbeitet");
        logwriter.flush();
        logwriter.close();
    } catch (IOException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }


}

}

封装mycode；
导入java.io.BufferedWriter；
导入java.io.File；
导入java.io.FileWriter；
导入java.io.IOException；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.concurrent.ExecutorService；
导入java.util.concurrent.Executors；
导入java.util.concurrent.TimeUnit；
公开课初学者{
公共静态void main（字符串[]args）{
文件配置=新文件（args[0]）；
起动机=新起动机（）；
starter.work（配置）；
}
私人作废工作（文件配置）
{
长启动=System.currentTimeMillis（）；
ConfigReader cr=新的ConfigReader（配置）；
cr.init（）；
FileFinder ff=新的FileFinder（）；
Listfiles=ff.findfiles（cr.getParam（“xmlfolder”）；
Listdone=newarraylist（）；
ExecutorService es=Executors.newFixedThreadPool（Integer.parseInt（cr.getParam（“max.threadcount”））；
用于（文件aktuell:文件）
{
执行（新线程启动程序（aktuell，cr.getParam（“注销输出”），完成））；
}
es.shutdown（）；
试一试{
等待终止（长最大值，时间单位，分钟）；
}捕捉（中断异常e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
Long end=System.currentTimeMillis（）；
缓冲写入日志写入程序；
试一试{
logwriter=new BufferedWriter（new FileWriter（新文件（cr.getParam（“logoutput”））.getAbsolutePath（）+“/log.log”）；
用于（字符串温度：完成）
{
logwriter.write（临时）；
logwriter.newLine（）；
}
logwriter.write（“Die Verarbeitung dauerte”+（结束-开始）/1000+“Sekunden”）；
logwriter.newLine（）；
logwriter.write（“Es wurden”+files.size（）+“Dienststellen verarbeite”）；
logwriter.flush（）；
logwriter.close（）；
}捕获（IOE1异常）{
//TODO自动生成的捕捉块
e1.printStackTrace（）；
}
}
}

我认为两者之间没有关系，也不是一个简单的关系。这取决于线程正在执行的作业。具有一个线程的程序可以消耗100%的CPU，而具有多个线程的程序可以消耗更少的CPU

---

如果您正在寻找线程和完成的工作之间的优化关系，您必须研究您的案例，并可能找到经验解决方案。

感谢您的回答

正如@hagrawal所写，使用1、10或100个线程之间没有区别。如果我使用的线程和列表中的文件一样多，那么我的CPU使用率就要高得多（直到CPU成为瓶颈），整个进程大约需要10%的时间。不幸的是，这需要大量的内存，我担心，这将导致软件崩溃，甚至在未来更多的文件

我无法想象，这可能是一个I/O问题。我的机器的raid 0系统应该能够做到这一点，而无需任何努力。如果我对问题的理解是正确的，那就不可能是I/O问题。因为如果I/O是瓶颈，那么如果线程数等于文件数（在我的例子中大约是1000个），性能就不会提高。还是我的造币厂出了什么问题

---

不幸的是，1、10和100个线程的CPU使用率几乎不一样。因此，我的印象是，进程从固定数量的线程（如配置的）开始，执行器服务等待所有线程终止，然后再开始新的线程。但我的理解是，一旦第一个线程终止并释放，它就会启动一个新线程

将

max.threadcount

指定为1和将其指定为100时，无法找到差异？你能提供一个最小的可重复代码吗？因为看这段代码，我认为你应该得到X个并行处理线程，其中X=

max.threadcount

。当你只使用一个线程运行时，进程花多少时间进行计算，花多少时间进行I/O？您的计算机可能有多个CPU，因此添加更多线程可以使其计算速度更快（最多可达您拥有的CPU数量），但如果所有这些文件都在同一磁盘上。。。只有一个端口可以与磁盘进行通信。添加更多线程根本不会提高I/O时间。