Exécution à l'exécution et éditeur RTF personnalisé

Question

J'ai une classe qui gère la création de documents RTF et une méthode de cette classe qui appelle l'éditeur RTF avec un fichier XML à afficher.

Tous les utilisateurs sauf un peuvent accéder à cet éditeur sans problème. Cet utilisateur se heurte systématiquement à un problème où son application se bloque. Il n'y a pas d'erreur dans les journaux. Normalement, ce genre de problème est facilement identifié, reproduit et corrigé. Cependant, je ne peux pas le reproduire pour le reste de ma vie et mes tentatives de débogage échouent.

En gros, le code est le suivant:

int exitVal = CUBSRTFEditor.runRTFEditor("c:\\tmp\\control"+ap_doc_id+".xml", xml,"I:\\AppealsLetters.exe /process \"c:\\tmp\\control"+ap_doc_id+".xml\"");

public static int runRTFEditor(String xmlLocation, String xmlContent, String executePath)
{
    int exitVal = 0;
    createLocalFile(xmlLocation, xmlContent);

    try
    {
        System.out.println("executePath must = "+executePath);
        Runtime rt = Runtime.getRuntime();
        Process proc = rt.exec(executePath);
        System.out.println("after executePath runs");

        //exhaust that stream before waiting for the process to exit
        InputStream inputstream = proc.getInputStream();
        InputStreamReader inputstreamreader = new InputStreamReader(inputstream);
        BufferedReader bufferedreader = new BufferedReader(inputstreamreader);
        // read the ls output
        String line;
        while ((line = bufferedreader.readLine())!= null)
        {
            System.out.println(line);
        }
        exitVal = proc.waitFor();
    }
    catch (Throwable t)
    {
        t.printStackTrace();
    }

    CUBSRTFEditor.deleteTempFile(xmlLocation);

    return exitVal;
}

La dernière sortie est la première System.out. Lorsque je prends le fichier XML et l'exécute sur n'importe quel autre PC, il s'exécute sans problème. Je ne vois aucune information utile dans proc.getErrorStream () ou proc.getOutputStream ().

La documentation Javadoc du JDK sur ce problème (exec suspendu): Etant donné que certaines plates-formes natives ne fournissent qu'une taille de mémoire tampon limitée pour les flux d'entrée et de sortie standard, le fait d'écrire rapidement le flux d'entrée ou de lire le flux de sortie du sous-processus peut entraîner le blocage du sous-processus, voire son blocage.

J'essaie d'épuiser ce flux avant d'attendre la fin du processus et cela ne semble pas aider car il ne semble jamais arriver à ce point (le second System.out n'est pas affiché)

Est-ce que j'ai mal implémenté ceci? Est-ce que je manque quelque chose d'important? Toutes les idées sur la façon d’obtenir plus d’informations en dehors du processus seraient géniales.

Je suis coincé ....

Answer 1

Runtime.exec () est un petit spud trompeur à utiliser. J'ai trouvé cet article (ancien, mais toujours d'actualité) pour être très utile. Vous pouvez toujours aller à la page 4 pour un exemple de code hautement gankable. : -)

En résumé, votre code doit gérer à la fois proc.getOutputStream () et proc.getErrorStream (), ce qui constitue une bonne raison de gérer ces flux dans des threads distincts.

Answer 2

Je voulais mettre à jour cette fonctionnalité, car la modification est entrée en production aujourd'hui et fonctionne. Sur la base des suggestions de BlairHippo, je lui ai demandé de travailler avec une classe interne anonyme pour créer un thread distinct qui épuise les flux Error et Input.

new Thread(new Runnable(){
    public void run()
    {
        try
        {
            BufferedReader br = new BufferedReader(new InputStreamReader(proc.getErrorStream()));
            String line;
            while ((line = br.readLine())!= null)
            {
                System.out.println(line);
            }
        }
        catch (Throwable t)
        {
            t.printStackTrace();
        }
    }
}).start();