En java déterminer si un processus est créé à l'aide de l'environnement d'Exécution a fini de l'exécution?

Runtime.getRuntime.exex("abc.exe -parameters");

à l'aide de .waitFor() n'aide pas à déterminer l'achèvement du processus.

Quel est le problème avec waitFor()?
waitFor la documentation dit qu'elle renvoie si le processus est arrêté. La valeur de retour est la valeur de sortie du processus. waitFor jette aussi un InterruptException si une interruption se produit. Pouvez-vous partager ce comportement que vous attendez de processus abc.exe? Vous pouvez avoir besoin de capturer la sortie d'erreur ou de ruisseaux.
Pouvez-vous indiquer pourquoi waitFor() ne vous aide pas dans ce cas? Votre déclaration est en contradiction avec la documentation, et j'ai confiance dans la documentation pas un hasard étranger sur Internet.
l'abc.exe fichier de code les messages d'un fichier à l'autre.Une fois que la tâche est terminée sa va pour une attente indéfinie(je ne sais pas pourquoi?).
Si le comportement de la abc.exe le processus est de faire quelque chose et puis de perdre du temps à ne rien faire, que votre processus ne va pas mettre fin et waitFor garder en attente pour elle. Compte tenu de cette information, la réponse à la question titre, c'est que le processus n'a jamais fini. Une hypothèse peut être faite que ce soit abc.exe est cassé ou mal compris.

OriginalL'auteur devashish jasani | 2011-07-29

  1. 9

    Process.waitFor() (javadoc) devrait travail. Si cela ne fonctionne pas alors soit:

    • il y a un bug dans la JVM ou de l'OS (très peu probable pour quelque chose de ce genre), ou

    • il ya quelque chose sur le processus et/ou votre code Java qui signifie que le processus ne sortie.

    Dans les versions actuelles de Java, vous pouvez également utiliser Process.isAlive (javadoc) pour tester l'état d'un processus sans blocage jusqu'à la fin. Pour Java 7 et plus il y a un hacky solution qui implique d'interroger le processus de retour de code et l'interception d'une exception, mais c'est inefficace. Vous devez mettre à jour Java 8 ou plus tard dès que possible!

    Une fois que la tâche est terminée sa va pour une attente indéfinie. (Je ne sais pas pourquoi).

    Si ce qui se passe, alors ni waitFor() ou isAlive() aidera.

    Les raisons les plus probables que d'un processus lancé à partir de Java ne sera pas /ne peut pas quitter le sont:

    • le processus est bloqué en attente de votre application Java pour lui donner une certaine entrée (par l'intermédiaire de son stdin),

    • le processus est bloqué en attente de votre application Java pour lire sa sortie (c'est à dire son stdout ou stderr),

    • il est bloqué en attente sur un événement extérieur; par exemple, si il essaye de parler serveur distant ne répond pas,

    • quelque chose a envoyé un signal d'ARRÊT d'un certain type, ou

    • il est juste de prendre un looong de temps à s'exécuter.

    Les deux premiers de ces raisons /causes peuvent être traitées par (respectivement) la fermeture de la Java flux de sortie connecté à l'entrée standard, et de la lecture (et, éventuellement, de les jeter) la Java les flux d'entrée connectée à la sortie standard et l'erreur standard. Les autres causes sont insolubles, et vos seules options sont à "attendre" ou d'essayer de tuer le processus.

    Bas de ligne que vous devez trouver pourquoi votre processus n'est pas complète. L'bloqué Process.waitFor() appel est un symptôme, pas la maladie.

    il en va pour une attente indéfinie, même après que la tâche est accomplie..
    Mettre cette information dans la description du problème en question. Astuce: utilisez le lien "modifier" en dessous de la question.
    vous avez besoin de savoir POURQUOI il le fait. Je vous ai donné quelques causes possibles, mais je ne peux pas ouvrir une enquête.

    OriginalL'auteur Stephen C

  2. 17

    Ressemble JDK8 introduit Processus.isAlive(). Surpris il a fallu si longtemps...

    En attendant, la meilleure option semble être de sondage Processus.exitValue(), enveloppé dans un try-catch:

    //somewhere previous...
String[] cmd = { "abc.exe", "-p1", "-p2" };
Process process = Runtime.getRuntime.exec(cmd);

//call this method repeatedly until it returns true
private boolean processIsTerminated () {
    try {
        process.exitValue();
    } catch (IllegalThreadStateException itse) {
        return false;
    }
    return true;
}

    Alternativement, une méthode similaire pourrait retourner la valeur de sortie si le processus a pris fin, ou une autre valeur spécifiée si pas.

    Ok, merci. Je pensais que les exceptions ne sont pas censés être utilisée pour le chemin d'accès du code. Mais si c'est le seul moyen... nous ne serons pas de portage à JDK8 pour longtemps encore.
    J'espère que vous l'avez fait aujourd'hui. Java 7 a été en fin de vie depuis 4 ans maintenant (et de comptage ....)

    OriginalL'auteur ericsoco

  3. 1

    J'ai un problème similaire, et qu'aucune des méthodes écrites ici fonctionne pour moi. C'est mon code:

    public void startCCleaner() {
    System.out.println("Starting ccleaner...");
    try {
        Process process = new ProcessBuilder("C:\\Program Files\\CCleaner\\CCleaner64.exe").start();
        if(process.waitFor() == 0 ){
            System.out.println("Process terminated ");
        }
    } catch (IOException e) {
        e.printStackTrace();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

    OriginalL'auteur Baxtex

  4. -1

    Si vous ne souhaitez pas utiliser waitFor(), qui, apparemment, vous n'avez pas, vous pouvez toujours tester la valeur de sortie directement. 

    import java.util.*;
import java.io.*;
public class ProcExitTest
{
    public static void main(String args[])
    {
        try
        {            
            Runtime rt = Runtime.getRuntime();
            Process proc = rt.exec("<....>");
            int exitVal = proc.exitValue();
            System.out.println("Process exitValue: " + exitVal);
        } 
          catch (InterruptedException ie)
          {
            ie.printStackTrace();
          }
    }
}

    code de sortie 0 signifie normale d'expiration.

    Attendez-vous quelque chose à être jetés? peut-être à partir de exitValue?
    C'est quelque chose que j'ai copié à partir d'un fichier que j'avais ouvert. Il peut encore attraper l'exception, comme elles sont "Lancer" des objets. Mais je suppose que mal de le modifier pour éviter la flopée de downvotes
    Certes, mais comme il n'existe pas de mécanisme pour permettre à la fin du processus dans votre code, l'appel à exitValue est susceptible de produire une exception.
    C'était juste un exemple de la façon dont les OP pourraient faire l'essai de la sortie de valeur, puisque c'est ce qu'ils ont dit qu'ils cherchaient. Je n'aurais jamais l'utiliser dans un programme, c'est un sacré morceau de code

    OriginalL'auteur Hunter McMillen