La lecture de flux de données à partir d'Exécution java.exec

J'ai l'extrait de code suivant:

Process proc = runtime.exec(command);
errorGobbler = new ErrorStreamGobbler(proc.getErrorStream(), logErrors, mdcMap);
outputGobbler = new OutputStreamGobbler(proc.getInputStream(), mdcMap);
executor.execute(errorGobbler);
executor.execute(outputGobbler);
processExitCode = proc.waitFor();

où la gobblers sont Runnables qui utilisent une BufferedReader pour lire l'entrée d'erreur et de flux de l'exécution de processus. Bien que cela fonctionne la plupart du temps, j'ai l'occasionnel fenêtre (environ 2 minutes) où je reçois le processExitCode que 0, ce qui indique normale d'expiration, mais il n'y a rien dans l'entrée d'erreur et de flux - rien à même d'indiquer en fin de flux.

Comme je l'ai indiqué avant, cela fonctionne la plupart du temps, mais cette panne se produit à chaque fois dans un certain temps - et je suis totalement perplexe. Des idées?

Chiffons

Un peu plus de contexte - c'est une application multi-thread, où beaucoup de l'Exécution.exec() se produisent simultanément. Chiffons
Tu veux dire que le flux de gobblers bloquer pour toujours?
Oui, ils le font! Ils ont juste accrocher...

OriginalL'auteur ragstorooks | 2010-07-27

  1. 12

    J'ai lutté avec le même genre de questions.
    Je ne me souviens pas exactement ce qui était mauvais (peut-être que j'ai oublié de vider /fermeture du flux correctement ou quelque chose ...).
    De toute façon, ici, c'est que je suis venu avec.

    /**
*  Handle communication with a process, reading its output/error and feeding its input
*  @param process The process to execute
*  @param _in Reader that will feed the input pipe of the process
*  @param out Writer that will receive the output of the process
*  @param err Writer that will receive the error pipe of the process
*/
public static void communicate(
Process process,
final Reader _in,
final Writer out,
final Writer err)
{
//Buffer the input reader
final BufferedReader in = new BufferedReader(_in);
//Final versions of the the params, to be used within the threads
final BufferedReader stdOut = new BufferedReader(new InputStreamReader(process.getInputStream()));
final BufferedReader stdErr = new BufferedReader(new InputStreamReader(process.getErrorStream()));
final BufferedWriter stdIn = new BufferedWriter(new OutputStreamWriter(process.getOutputStream()));
//Thread that reads std out and feeds the writer given in input
new Thread() {
@Override public void run() {
String line;
try {
while ((line = stdOut.readLine()) != null) {
out.write(line + newline);
}
} catch (Exception e) {throw new Error(e);}
try {
out.flush();
out.close();
} catch (IOException e) { /* Who cares ?*/ }
}
}.start(); //Starts now
//Thread that reads std err and feeds the writer given in input
new Thread() {
@Override public void run() {
String line;
try {
while ((line = stdErr.readLine()) != null) {
err.write(line + newline);
}
} catch (Exception e) {throw new Error(e);}
try {
err.flush();
err.close();
} catch (IOException e) { /* Who cares ?*/ }
}
}.start(); //Starts now
//Thread that reads the std in given in input and that feeds the input of the process
new Thread() {
@Override public void run() {
String line;
try {
while ((line = in.readLine()) != null) {
stdIn.write(line + newline);
}
} catch (Exception e) {throw new Error(e);}
try {
stdIn.flush();
stdIn.close();
} catch (IOException e) { /* Who cares ?*/ }
}
}.start(); //Starts now
//Wait until the end of the process
try {
process.waitFor();
} catch (Exception e) {
throw new Error(e);
}
} //End of #communicate

    J'espère que cette aide.

    Je faisais déjà tout cela, et était encore voir beaucoup de ces questions. Après beaucoup d'essais et d'erreurs, je pense que j'ai enfin compris: le pool de threads (même si elle ne devrait pas avoir) et les threads de lire le flux n'a jamais vraiment commencé. Je vais prendre cette question au Printemps forums! (Je suis en utilisant leur pool de threads mise en oeuvre) Merci pour vos commentaires!

    OriginalL'auteur Raphael Jolivet