Java ProcessBuilder进程未运行

我对ProcessBuilder和线程的使用还比较陌生。在它的当前状态下，我有一个J按钮，用于启动计划执行器服务。scheduled executor服务用于将流程委托给两个流程构建器之一。应用程序用于记录用户对话。在对话过程中，x分钟后，它创建一个wav并将其委托给一个可用的进程进行转录。当调用transcription类时，问题就开始了。进程启动，应用程序按预期运行。然而，在我退出父应用程序之前，转录过程实际上不会做任何事情。只有到那时它才会开始。检查任务管理器，它显示为一个进程，但使用0.0%的CPU和大约238MB的内存，直到我退出，然后这两个进程跳到30%-40%和500-1000 MB的内存。另外，我使用的是.waitFor（），但使用的是一个线程来运行.waitFor（）进程，因为从我收集的信息来看，它会导致应用程序挂起。我将如何着手解决这个问题。很抱歉，我无法提供更多的细节，但我是新手。提前谢谢

public class TranDelegator {
    Future<?> futureTranOne = null;
    Future<?> futureTranTwo = null;
    ExecutorService transcriberOne = Executors.newFixedThreadPool(1);
    ExecutorService transcriberTwo = Executors.newFixedThreadPool(1);

    final Runnable transcribeChecker = new Runnable() {
        public void run() {
            String currentWav = null;
            File inputFile = new File("C:\\convoLists/unTranscribed.txt");

            BufferedReader reader = null;
            try {
                reader = new BufferedReader(new FileReader(inputFile));
            } catch (FileNotFoundException e1) {
                System.out.println("reader didn't initialize");
                e1.printStackTrace();
            }
            try {
                currentWav = reader.readLine();
            } catch (IOException e) {
                System.out.println("currentWav string issue");
                e.printStackTrace();
            }
            try {
                reader.close();
            } catch (IOException e) {
                System.out.println("reader couldn't close");
                e.printStackTrace();
            }

            if(currentWav != null){
                if (futureTranOne == null || futureTranOne.isDone()) {
                    futureTranOne = transcriberOne.submit((transcriptorOne));
                }

                else if (futureTranTwo == null || futureTranTwo.isDone()) {                     
                    futureTranTwo = transcriberTwo.submit((transcriptorTwo));               
                }
            }
        }
    };

    final Runnable transcriptorOne = new Runnable() {
        public void run() {
            System.out.println("ONE");
            try {
                String classpath = System.getProperty("java.class.path");
                String path = "C:/Program Files/Java/jre7/bin/java.exe";
                ProcessBuilder processBuilder = new ProcessBuilder(path, "-cp",
                        classpath, Transcriber.class.getName());
                Process process = processBuilder.start();
                try {
                    process.waitFor();
                } catch (InterruptedException e) {
                    System.out.println("process.waitFor call failed");
                    e.printStackTrace();
                }
            } catch (IOException e) {
                System.out.println("Unable to call transcribeConvo");
                e.printStackTrace();
            }

        }
    };
    final Runnable transcriptorTwo = new Runnable() {
        public void run() {
            System.out.println("TWO");
            try {
                String classpath = System.getProperty("java.class.path");
                String path = "C:/Program Files/Java/jre7/bin/java.exe";
                ProcessBuilder processBuilder = new ProcessBuilder(path, "-cp",
                        classpath, Transcriber.class.getName());
                Process process = processBuilder.start();
                try {
                    process.waitFor();
                } catch (InterruptedException e) {
                    System.out.println("process.waitFor call failed");
                    e.printStackTrace();
                }
            } catch (IOException e) {
                System.out.println("Unable to call transcribeConvo");
                e.printStackTrace();
            }
        }
    };

}


public class Transcriber {
    public static void main(String[] args) throws IOException,
            UnsupportedAudioFileException {
        retreiveEmpInfo();
        TextoArray saveConvo = new TextoArray();
        ArrayList<String> entireConvo = new ArrayList();
        URL audioURL;
        String currentWav = wavFinder();
        ConfigReader configuration = new ConfigReader();
        ArrayList<String> serverInfo = configuration
                .readFromDoc("serverconfig");

        while (currentWav != null) {
            audioURL = new URL("file:///" + currentWav);
            URL configURL = Transcriber.class.getResource("config.xml");
            ConfigurationManager cm = new ConfigurationManager(configURL);
            Recognizer recognizer = (Recognizer) cm.lookup("recognizer");
            recognizer.allocate(); // allocate the resource necessary for the
                                    // recognizer
            System.out.println(configURL);

            // configure the audio input for the recognizer
            AudioFileDataSource dataSource = (AudioFileDataSource) cm
                    .lookup("audioFileDataSource");
            dataSource.setAudioFile(audioURL, null);

            // Loop until last utterance in the audio file has been decoded, in
            // which case the recognizer will return null.
            Result result;
            while ((result = recognizer.recognize()) != null) {

                String resultText = result.getBestResultNoFiller();
                // System.out.println(result.toString());
                Collections.addAll(entireConvo, resultText.split(" "));
            }
            new File(currentWav).delete();
            saveConvo.Indexbuilder(serverInfo, entireConvo);
            entireConvo.clear();
            currentWav = wavFinder();
        }
        System.exit(0);
    }

    private static String wavFinder() throws IOException {
        String currentWav = null;
        int x = 1;
        File inputFile = new File("C:\\convoLists/unTranscribed.txt");
        File tempFile = new File("C:\\convoLists/unTranscribedtemp.txt");

        BufferedReader reader = new BufferedReader(new FileReader(inputFile));
        BufferedWriter writer = new BufferedWriter(new FileWriter(tempFile));
        String currentLine = null;
        String newLine = System.getProperty("line.separator");

        while ((currentLine = reader.readLine()) != null) {
            if (x == 1) {
                currentWav = currentLine;
            } else {
                writer.write(currentLine);
                writer.write(newLine);
            }
            x = 2;
        }
        reader.close();
        writer.flush();
        writer.close();
        inputFile.delete();
        // boolean successful =
        tempFile.renameTo(inputFile);
        // System.out.println("Success: " + successful);
        // System.out.println("currentWav = " + currentWav);
        return currentWav;
    }

    private static void retreiveEmpInfo() throws IOException {
        File tempFile = new File("C:\\convoLists/tmp.txt");

        BufferedReader reader = new BufferedReader(new FileReader(tempFile));
        CurrentEmployeeInfo.setName(reader.readLine());
        CurrentEmployeeInfo.setUserEmail(reader.readLine());
        CurrentEmployeeInfo.setManagerEmail(reader.readLine());
        reader.close();
    }
}

公共类传输委托器{
Future-futureTranOne=null；
Future futureTranTwo=空；
ExecutorService transcriberOne=Executors.newFixedThreadPool（1）；
ExecutorService transcriberTwo=Executors.newFixedThreadPool（1）；
最终可运行转录检查器=新可运行（）{
公开募捐{
字符串currentWav=null；
File inputFile=新文件（“C:\\convalists/untranscripted.txt”）；
BufferedReader reader=null；
试一试{
reader=newbufferedreader（newfilereader（inputFile））；
}捕获（FileNotFoundException e1）{
System.out.println（“读卡器未初始化”）；
e1.printStackTrace（）；
}
试一试{
currentWav=reader.readLine（）；
}捕获（IOE异常）{
System.out.println（“当前WAV字符串问题”）；
e、 printStackTrace（）；
}
试一试{
reader.close（）；
}捕获（IOE异常）{
System.out.println（“读卡器无法关闭”）；
e、 printStackTrace（）；
}
如果（currentWav！=null）{
if（futureTranOne==null | | futureTranOne.isDone（））{
futureTranOne=转录因子提交（（转录因子））；
}
else如果（futureTranTwo==null | | futureTranTwo.isDone（））{
futureTranTwo=转录两次提交（（转录两次））；
}
}
}
};
final Runnable transcriptorOne=新Runnable（）{
公开募捐{
系统输出打印项次（“一”）；
试一试{
字符串classpath=System.getProperty（“java.class.path”）；
String path=“C:/Program Files/Java/jre7/bin/Java.exe”；
ProcessBuilder ProcessBuilder=新的ProcessBuilder（路径“-cp”，
classpath，Transcriber.class.getName（））；
Process=processBuilder.start（）；
试一试{
process.waitFor（）；
}捕捉（中断异常e）{
System.out.println（“process.waitFor调用失败”）；
e、 printStackTrace（）；
}
}捕获（IOE异常）{
System.out.println（“无法调用TranscribeColva”）；
e、 printStackTrace（）；
}
}
};
最终可运行转录本two=新可运行（）{
公开募捐{
System.out.println（“两个”）；
试一试{
字符串classpath=System.getProperty（“java.class.path”）；
String path=“C:/Program Files/Java/jre7/bin/Java.exe”；
ProcessBuilder ProcessBuilder=新的ProcessBuilder（路径“-cp”，
classpath，Transcriber.class.getName（））；
Process=processBuilder.start（）；
试一试{
process.waitFor（）；
}捕捉（中断异常e）{
System.out.println（“process.waitFor调用失败”）；
e、 printStackTrace（）；
}
}捕获（IOE异常）{
System.out.println（“无法调用TranscribeColva”）；
e、 printStackTrace（）；
}
}
};
}
公共类转录器{
公共静态void main（字符串[]args）引发IOException，
不支持DaudioFileException{
retreiveEmpInfo（）；
TextoArray saveconva=新TextoArray（）；
ArrayList entireConvo=新的ArrayList（）；
URL音频URL；
字符串currentWav=wavFinder（）；
ConfigReader配置=新建ConfigReader（）；
ArrayList serverInfo=配置
.readFromDoc（“服务器配置”）；
while（currentWav！=null）{
audioURL=新URL（“文件：//”+currentWav）；
URL configURL=Transcriber.class.getResource（“config.xml”）；
ConfigurationManager cm=新的ConfigurationManager（configURL）；
识别器识别器=（识别器）cm.查找（“识别器”）；
recognizer.allocate（）；//分配任务所需的资源
//识别器
System.out.println（configURL）；
//为识别器配置音频输入
AudioFileDataSource数据源=（AudioFileDataSource）cm
.lookup（“audioFileDataSource”）；
setAudioFile（audioURL，null）；
//循环，直到音频文件中的最后一句话被解码，在
//在这种情况下，识别器将返回null。
结果；
而（（result=recognizer.recognize（））！=null）{
字符串结果文本
ProcessBuilder processBuilder = new ProcessBuilder(command);
Process process = processBuilder.start();
InputStream inStream = process.getInputStream();
InputStream errStream = process.getErrorStream();
try {
    inStream.close();
    errStream.close();
} catch (IOException e1) {
}
process.waitFor();

    ProcessBuilder processBuilder = new ProcessBuilder(command);
    Process process = processBuilder.start();
    InputStreamReader tempReader = new InputStreamReader(new BufferedInputStream(p.getInputStream()));
    final BufferedReader reader = new BufferedReader(tempReader);
    InputStreamReader tempErrReader = new InputStreamReader(new BufferedInputStream(p.getErrorStream()));
    final BufferedReader errReader = new BufferedReader(tempErrReader);

    try {
        while ((line = reader.readLine()) != null) {
        }
    } catch (IOException e) {
    }

    try {
        while ((line = errReader.readLine()) != null) {
        }
    } catch (IOException e) {
    }
    process.waitFor();

ProcessBuilder processBuilder = new ProcessBuilder(command);
processBuilder.redirectInput();
processBuilder.redirectError();
Process process = processBuilder.start();
process.waitFor();