Vitesse exécution Runtime.exec()

Version imprimable

20/06/2011, 10h13
NicoTheDude

Vitesse exécution Runtime.exec()

Bonjour,

Contexte : Application Web JAVA / Serveur Tomcat

Je suis étonné de la lenteur d'exécution des commandes lancées par mon appli avec la méthode Runtime.exec()
En effet, une commande lancée en shell directement me prend trois secondes au lieu de 10 lors de l'exécution du programme JAVA.

Auriez vous une explication voire une solution pour améliorer la vitesse d'exécution de ma commande shell?

Merci
20/06/2011, 11h32
sinok

Gères tu correctement les flux standard d'entrée/sortie/erreur de ton Runtime.exec (sont ils bien consommés)?

http://ydisanto.developpez.com/tutoriels/j2se/runtime/
http://blog.developpez.com/adiguba/p...s-plus-simple/
20/06/2011, 13h52
NicoTheDude

Est-il nécessaire de traiter ces flux?
Je lance simplement l'exec puis j'attends que le Process soit terminé avec waitfor() pour le moment, je ne m'occupe pas de ce qui se passe en console.
20/06/2011, 13h54
NicoTheDude

J'ai ajouté le traitement des flux comme indiqués dans tes liens et j'obtiens toujours le même temps. J'ai pourtant bien deux Threads séparés qui traitent le flux standard et le flux d'erreur.
Le problème ne semble donc pas venir de là mais ca semblait etre une bonne idée, merci.
20/06/2011, 19h30
adiGuba

Salut,

Il faut TOUJOURS traiter les flux (ou les fermer) sous peine d'avoir un dead-lock entre les deux programmes.

Quand à ton problème, il faudrait en savoir plus sur ta commande ? Comment tu la lances dans le shell, le code java correspondant, ce qu'elle fait, etc...

a++

Bonjour,

Voilà le morceau de code principal qui me sert à lancer un commande.
J'ai donc deux threads pour gérer les flux :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
final Process p;
        try {
            // Consommation de la sortie standard et de la sortie d'erreur des scripts
            p = Runtime.getRuntime().exec(command);
            new InputThread(p.getInputStream(), session).start();
            new InputThread(p.getErrorStream(), session).start();
            p.waitFor();
            exitValue = p.exitValue();
        }
        catch (IOException ex) {
            java.util.logging.Logger.getLogger(ExecScript.class.getName()).log(Level.SEVERE, null, ex);
        }
        catch (InterruptedException ex) {
            //ex.printStackTrace();
            logger.logTraceMessage(session,"<h5 class=\"error\">Unexpected error while executing" + StringEscapeUtils.escapeHtml(command.toString()) + "</h5> \n");
            exitValue = 1;
            return;
        }

Je lance une commande shell (donc un script ".sh") via Java en utilisant le code ci-dessus qui est dans une fonction que j'appelle a chaque fois que je veux exécuter un script.
la commande shell elle-même appelle un script en C...

Est ce que cela vous suffit comme info? Voyez vous des pistes de réflexion sur lesquelles me pencher?

Merci

Citation:

Envoyé par NicoTheDude

Je lance une commande shell (donc un script ".sh")

Lequel ? Et que fait-il exactement ! Cela peut rentrer en compte.

Sinon pour le code :

Il faut fermer les flux inutilisés (getOutputStream() dans ton cas).
Depuis Java 5 il faut privilégier ProcessBuilder à Runtime.exec(), en séparant bien les différents paramètres de la commande.
Pas besoin de créer forcément deux threads : tu peux lire un des flux dans le thread courant ;)
Mieux avec ProcessBuilder tu peux cumuler les flux de sorties standard et d'erreur avec redirectErrorStream() pour n'en avoir qu'un seul à lire sans avoir besoin de créer de thread supplémentaire...

Bref ton code pourrait ressembler à ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 final Process p = new ProcessBuilder("cmd", "/C", "dir") .redirectErrorStream(true) .start(); // On ferme les flux inutiles : p.getOutputStream().close(); p.getErrorStream().close(); InputStream input = p.getInputStream(); try { // Copie sur stdout : byte[] buf = new byte[8192]; int len; while ( (len=input.read(buf)) >= 0 ) System.out.write(buf, 0, len); } finally { input.close(); } p.waitFor();
a++

21/06/2011, 10h44
NicoTheDude

Mon script shell lance des actions de compilation sur du code C avec gcc et fait tourner une application Caml prenant en paramètre le code C par exemple.
Je n'en sais guère plus pour le moment. Cela vous suffit il?

Merci pour tes corrections de mon code, je vais les appliquer de ce pas, c'est sympa!
21/06/2011, 11h19
tchize_

Il n'y a pas de raison pour que ce soit plus rapide en shell que par java, java ne fait au final qu'un appel à fork puis exec, le process créé ne dépend pas de java.

La seul chose que je verrrais, c'est si java a une priorité moindre dans le système, tous les process qu'il pourra lancer hériteront aussi de cette priorité moindre, mais ça voudrais dire qu'on a volontairement bridé ton processus java :?

Par curiosité quand tu lance dans un shell, tu lance comment, tu utilise bien la commande

Code:

time tonApplicationShell.sh

pour faire ta mesure? Et sur la même machine?

Aussi quelle est la verbosité du script? Si il génére des centaines de miliers de lignes de texte et que tu stocke tout ça coté java, tu va ralentir à cause de ta consommation mémoire coté java, qui va restreindre la consommation des inputstream qui aura un effet d'engorgement sur le script. Pour faire une mesure dans l'absolu, commencer par simplement cloturer les stream (méthodes close()) :)
21/06/2011, 11h32
NicoTheDude

J'utilise bien cette commande pour mesurer la vitesse d'exécution lorsque je lance en shell :

Code:

time tonApplicationShell.sh

Les Stream ne renvoient que quelques lignes donc ce n'est pas de ce coté qu'il faut chercher... En les fermant, c'est identique.

Oui, je compare sur la même machine bien sûr.

"java a une priorité moindre dans le système" -> J'avais en effet pensé que ca pouvait venir du fait que mon processus lancé par java n'était pas prioritaire, comment vérifier cela?
21/06/2011, 11h50
tchize_

Code:

ps -eo pid,nice,user,args --sort user

La deuxième colonne est le niveau de gentilesse, plus il est élévé, moins le processus est prioritaire.

Regarde aussi dans les variables d'environnement, il faudrait comparer les output console des deux appels, gcc est très sensibles aux variables d'environnements pour ses opération, il suffit d'un CFLAGS=-o3 dans l'environnement par exemple pour qu'il fasse l'optimisation de code la plus poussée (et donc la compilation la plus lente) ;)

éventuellement rejoute ceci en tête de script

Code:

env | sort

et compare les dux sorties ;)
21/06/2011, 12h02
NicoTheDude

Hmmmm... je viens de penser à quelque chose.

J'ai créé un nouveau programme java qui ne fait que lancer le script et uniquement cela. L'exécution s'est bien passée et a été rapide.

Cela peut peut être venir du fait que dans mon application - l'autre où c'est lent -, le lancement de ce script est fait dans un Thread particulier ?

Je vais essayer tes commandes.

Merci pour votre aide!
21/06/2011, 12h29
NicoTheDude

Bon, j'ai résolu le problème...

Le problème est que pendant que je lance ce script, j'ai une machine virtuelle qui est en train de se lancer et qui bouffe plein de ressources.

En effet, si j'attends la fin du lancement d ecette VM pour lancer mon script, il se termine vite.

Désolé pour le dérangement, problème résolu.
Merci pour votre aide.