Java 为什么在这段代码中ProcessBuilder的执行会影响主线程？

在这个程序中，主线程中10分钟后，开始时间和当前时间之间的差值增加到1秒以上，最多8秒。为什么会发生这种情况process builder会影响主线程执行

java版本“1.6.0_26”

Java（TM）SE运行时环境（build 1.6.0_26-b03）

Java HotSpot（TM）服务器虚拟机（构建20.1-b02，混合模式

OS: Solaris 

---

导入java.io.BufferedReader；
导入java.io.InputStreamReader；
导入java.util.ArrayList；
导入java.util.Date；
导入java.util.List；
导入java.util.concurrent.ExecutorService；
导入java.util.concurrent.Executors；
公共类测试{
public ExecThread getExecThread（字符串cmd，int callNumberStart）{
返回新的ExecThread（cmd，callNumberStart）；
}
公共类ExecThread实现可运行{
私有字符串cmd；
私有int callNumberStart；
public ExecThread（字符串cmd，int callNumberStart）{
this.cmd=cmd；
this.callNumberStart=callNumberStart；
}
公共字符串executeCommand（字符串origLegCallId，字符串cmd）{
Process=null；
字符串cmdOutput=null；
试一试{
List命令=new ArrayList（）；
字符串[]splittedCmd=cmd.split（\\s+）；
for（字符串tmp:splittedCmd）{
添加命令（tmp）；
}
ProcessBuilder=新的ProcessBuilder（命令）；
process=builder.start（）；
process.waitFor（）；
InputStreamReader isr=新的InputStreamReader（process.getInputStream（））；
BufferedReader br=新的BufferedReader（isr）；
字符串行=null；
cmdOutput=新字符串（）；
而（（line=br.readLine（））！=null）{
cmdOutput=cmdOutput+行；
}
}捕获（例外情况除外）{
例如printStackTrace（）；
cmdOutput=null；
}
返回输出；
}
@凌驾
公开募捐{
while（true）{
System.out.println（callNumberStart+“：：”+线程.currentThread（）.getName（）+“：：开始”+
新日期（））；
字符串输出=executeCommand（“+callNumberStart，cmd）；
System.out.println（Thread.currentThread（）.getName（）+“输出为：”+Output）；
System.out.println（callNumberStart+“：：”+线程.currentThread（）.getName（）+“：：End”+n
ew Date（））；
callNumberStart++；
}
}
}
公共静态void main（字符串参数[]）{
int numberOfThread=100；
String cmd=/home/run.sh；//{sleep 5；echo'hello'}
ExecutorService es=Executors.newFixedThreadPool（numberOfThread）；
ExecTest test=新的ExecTest（）；
for（int i=1；i因为这个
进程。waitFor（）；

查看javadoc

编辑1：

再次查看代码后，您似乎没有关闭流，因此消耗大量资源的速度非常快（许多线程正在执行IO）。
每个进程的启动和关闭都需要时间。在现实世界中，没有什么是瞬时的；）进程。waitFor（）是在不同的线程（固定执行器池的线程）上调用的不在主线程上。您正在关闭输入流吗？听起来太多线程正在快速消耗资源。
import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;


public class ExecTest {

        public ExecThread getExecThread(String cmd, int callNumberStart) {
                return new ExecThread(cmd, callNumberStart);
        }

        public class ExecThread implements Runnable {

                private String cmd;
                private int callNumberStart;

                public ExecThread(String cmd, int callNumberStart) {
                        this.cmd = cmd;
                        this.callNumberStart = callNumberStart;
                }

                public String executeCommand(String origLegCallId, String cmd) {
                        Process process = null;
                        String cmdOutput = null;
                        try {
                                List<String> command = new ArrayList<String>();
                                String[] splittedCmd = cmd.split("\\s+");
                                for(String tmp : splittedCmd){
                                        command.add(tmp);
                                }
                                ProcessBuilder builder = new ProcessBuilder(command);
                                process = builder.start();
                                process.waitFor();
                                InputStreamReader isr = new InputStreamReader(process.getInputStream());
                                BufferedReader br = new BufferedReader(isr);
                                String line = null;
                                cmdOutput = new String();
                                while ((line = br.readLine()) != null) {
                                        cmdOutput = cmdOutput + line;
                                }
                        } catch (Exception ex) {
                                ex.printStackTrace();
                                cmdOutput = null;
                        }
                        return cmdOutput;
                }


                @Override
                public void run() {
                        while (true) {
                                System.out.println(callNumberStart + ":: " + Thread.currentThread().getName() + ":: Start " +
 new Date());
                                String output=executeCommand("" + callNumberStart, cmd);
                                System.out.println(Thread.currentThread().getName()+"Output is:"+output);
                                System.out.println(callNumberStart + ":: " + Thread.currentThread().getName() + ":: End " + n
ew Date());
                                callNumberStart++;
                        }

                }

        }

        public static void main (String args []) {
                int numberOfThread =100;
                String cmd = /home/run.sh; //{sleep 5;echo 'hello'}
                ExecutorService es = Executors.newFixedThreadPool(numberOfThread);

                ExecTest test=new ExecTest();

                for (int i = 1; i <= numberOfThread; i++) {
                        es.submit(test.getExecThread(cmd, i*10000));
                }

                while (true) {

                        long startTime = System.currentTimeMillis();
                        for (int j=0; j<5; j++) {
                                try {
                                        Thread.sleep(200);
                                } catch (InterruptedException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                }
                        }
                        System.out.println("Processing Time:: " + (System.currentTimeMillis()-startTime));
                }

        }

}