Question

我想在生成过程中读取进程的标准输出。该过程将发送进度指示器的信息，因此我一次获取所有信息是没有意义的，我这样做，哪个是问题。我尝试按照帖子中的建议使用Scanner类，但是我仍然只在进程完成后才获得输出。我之前已经意识到这个问题，但是没有得到回答。

您可能希望首先查看StreamGobblerOutput类。

    public List<String> executeCall(String fileName) 
    {
    StringBuilder sbOutput = new StringBuilder();
    StringBuilder sbError = new StringBuilder();

    File file = new File(fileName);
    try ( BufferedReader br = new BufferedReader(new FileReader(file)) ) {
        String line;
        while ((line = br.readLine()) != null) {
           String [] parts = line.split("\\s");
           if(parts.length<2) {
               sbError.append("Command too short for call: " + parts[0]);
               continue;
           }

            List<String> args = new ArrayList<String>();
            args.add ("sfb.exe");
            for(int i = 1; i <parts.length; ++i) {
                args.add (parts[i]);
            }
            args.add (sfbPassword);

            ProcessBuilder pb = new ProcessBuilder (args);
            pb.directory(new File(Support.getJustThePathFromFile(file)));
            Map<String, String> envs = pb.environment();
            String path = envs.get("Path");
            envs.put("Path", Paths.get(".").toAbsolutePath().normalize().toString() + ";" +path);


            //pb.redirectOutput(new Redirect() {});
            Process p = pb.start();

            String outputPathPrefix = pb.directory().getCanonicalPath();

            // any output?
            StreamGobblerOutput outputGobbler = new StreamGobblerOutput(p.getInputStream(), outputPathPrefix);
            outputGobbler.start();

            // any errors?
            StreamGobblerError errorGobbler = new StreamGobblerError(p.getErrorStream());
            errorGobbler.start();


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

            sbOutput = outputGobbler.getOutput();
            sbError = errorGobbler.getErrors();

            String rootPath= Support.getJustThePathFromFile(new File(fileName));
            File rootFile = new File(rootPath + "/..");
            String rootFolder = rootFile.getCanonicalFile().getName();
            System.err.println("rootFolder: " + rootFolder);
            mainApp.addModifiedFiles(outputGobbler.getModifiedFileNames(), rootFolder);

        }
    } catch ( IOException ex) {
        sbError.append(ex.getMessage());
    }

    mainApp.addOutput(sbOutput.toString());
    mainApp.addError(sbError.toString());

    return;

}

    private class StreamGobblerOutput extends Thread {
        private InputStream is;
        private String outputPathPrefix;
        private StringBuilder sbOutput;
        private List<String> modifiedFileNames;
        private Scanner scanner;

        private StreamGobblerOutput(InputStream is, String outputPathPrefix) {
            this.is = is;
            this.outputPathPrefix = outputPathPrefix;
            sbOutput = new StringBuilder();
            modifiedFileNames = new ArrayList<String>();
            scanner = new Scanner(is);
        }

        public StringBuilder getOutput() {
            return sbOutput;    
        }

        public List<String> getModifiedFileNames() {
            return modifiedFileNames;       
        }

        @Override
        public void run() {
            //create pattern
            Pattern patternProgress = Pattern.compile("\\((\\d+)%\\)");

            //InputStreamReader isr = new InputStreamReader(is);
            //BufferedReader br = new BufferedReader(isr);
            String ligne = null;
            while (scanner.hasNextLine()) {
                ligne = scanner.nextLine();

                sbOutput.append(ligne);
                sbOutput.append("\r\n");
                //bw.write("\r\n");

                Matcher mProgress = patternProgress.matcher(ligne);
                if (mProgress.find()) {
                    int percentage = Integer.parseInt(mProgress.group(1));
                    System.err.println("percentage=" + percentage);
                    mainApp.mainWindowController.setProgressExecute(percentage/100.0);
                }
            }
            mainApp.mainWindowController.setProgressExecute(1.0);
            if (scanner != null) {
                scanner.close();
             }
        }
    }

    private class StreamGobblerError extends Thread {
        private InputStream is;
        private StringBuilder sbError;
        private Scanner scanner;

        private StreamGobblerError(InputStream is) {
            this.is = is;
            sbError = new StringBuilder();
            scanner = new Scanner(is);
        }

        public StringBuilder getErrors() {
            return sbError;     
        }

        @Override
        public void run() {
            //InputStreamReader isr = new InputStreamReader(is);
            //BufferedReader br = new BufferedReader(isr);
            String ligne = null;
            while (scanner.hasNextLine()) {
                ligne = scanner.nextLine();
                sbError.append(ligne);
                sbError.append("\r\n");
            }
            if (scanner != null) {
                scanner.close();
             }
        }
    }

更新：我尝试将输出重定向到一个文件并从中读取，但看起来这会遇到与前一个实现相同的缓冲问题：我只获得两个数据点。

作为一种解决方法，我将不得不要求.exe的创建者在显示进度的每一行中包含4100个额外字符。

Answer 1

如果你的外部进程是基于C / C ++（stdio）的，那么这很可能是一个块缓冲问题：

基于stdio的程序作为规则是行缓冲的，如果它们在终端中以交互方式运行，并且当它们的stdout被重定向到管道时阻止缓冲。在后一种情况下，在缓冲区溢出或刷新之前，您不会看到新的行。

请参阅this answer了解更多详情和一些可能的解决方法。

另请注意，根据this，在Win32上不能选择行缓冲：

<强> _IOLBF 对于某些系统，这提供了行缓冲。但是，对于Win32，行为与_IOFBF - Full Buffering相同。

所以如果你选择修改＆＃34; exe＆＃34;要使用setvbuf设置正确的输出模式的程序，您必须使用：

_IONBF No buffer

代替。

Answer 2

来自Javadocs

可选地，可以创建PrintStream以便自动刷新; 这意味着在一个字节后自动调用flush方法写入数组，调用println方法之一，或换行写入字符或字节（＆＃39; \ n＆＃39;）。

参考：http://docs.oracle.com/javase/8/docs/api/java/io/PrintStream.html

执行此操作的一种方法是在每次写入后使输出流flush（）。 System.out.flush（）
您也可以定义自己的可刷新PrintStream并使用它。

Java读取进程输出无缓冲/实时

2 个答案: