L'exécution de java runtime.exec() pour de multiples processus

Dans mon programme j'ai une liste de n éléments.

Je vais être en itérant la liste et de lancer un processus comme ceci:

Runtime.getRuntime.exec("cmd /C start abc.bat"+listitem() )

J'ai besoin de maintenir un décompte de 4 processus. Une fois tout le processus est terminé, j'ai besoin de commencer le processus , de sorte que le processus de comptage doit être 4.

Je suis en mesure d'initier des 4 processus en même temps, mais vous ne savez pas comment faire pour garder le nombre de 4. Fondamentalement, j'ai besoin d'une notification une fois qu'un processus est terminé, pour que je puisse commencer la prochaine, tout le filetage est possible.

Toute aide sur la façon de le mettre en œuvre, quelqu'un peut-il partager un morceau sur cette exigence?

OriginalL'auteur Vigneshwaran | 2013-08-02

java runtime.exec

1

Vous devez avoir quatre threads qui prennent chacun une cession d'une piscine, puis la remplir, puis quand c'est fait, effectuer la tâche suivante. Ce serait comment:
```
class Whatever extends Thread {
    public void run() {
        while (!interrupted()) {
            String str = listitem();
            if (str == null) //there are no more commands to run
                break;
            Runtime.getRuntime.exec(("cmd /C start abc.bat"+str).split("\\s")).waitFor();
}
```
Puis commencer à quatre de ces threads.

Toutes cette solution n'est de transformer le problème de la gestion de sous-processus du cycle de vie pour la gestion des thread cycle de vie. Prendre exemple sur les autres answerers et de le jeter dans un ExecutorService comme je l'ai mentionné dans ma réponse..
Son exemple est complet, il a un temps d'Exécution.getRuntime et je peux juste copier coller complètement dans mon code. Aviez-vous fait la même chose, la vôtre aurait probablement été la bonne réponse...
Le but n'est DONC pas nécessairement de créer un copier/coller de réponses, mais plutôt de bonnes réponses. Mon commentaire est encore tout à fait valable et cette réponse est de mauvaise qualité, mais c'est le cas des OP droit d'accepter toute réponse qu'ils choisissent.
Comme vous l'avez dit, les gens ont le droit de choisir. Et moi, monsieur, choisir de ne pas nuage de ma tête avec tous les trucs sur des choses sur les choses.
une chose est sûre. stackoverflow.com/questions/541487/... stackoverflow.com/questions/10723346/...

OriginalL'auteur tbodt
12

Utiliser un ThreadPoolExecutor de taille 4 et un Runnable de mise en œuvre qui commence le Process puis invoque Process.waitFor(). Depuis le pool de threads sera limité à 4 fils et 4 fils va commencer un processus, puis attendre pour cela, vous serez assuré qu'il ne sera pas plus de 4 enfants les processus en cours d'exécution.

Un exemple de code pour vous aider le long de votre chemin:
```
ExecutorService executor = Executors.newFixedThreadPool(4);

executor.execute(new Runnable() {
    public void run() {
        //use ProcessBuilder here to make the process
        Process p = processBuilder.start();
        p.waitFor();
    }
});
```
Qui ajoute votre runnables pour le pool de threads?
Le thread principal? L'entrée de fil? Je ne vais pas écrire le programme pour l'OP, juste point sur un bon chemin.
Tim Bender : +1 . Félicitations à 10k 🙂
Je vous remercie. 🙂 Je craque sur les downvotes assez vite.

OriginalL'auteur Tim Bender

 public class ProcessRunner {

    public static void main(String[] args) throws IOException, InterruptedException {
        //Creating n threads as required
        ExecutorService exec = Executors.newFixedThreadPool(4);
        for(int i = 0; i < 4; i++){
            exec.execute(new ProcessRunnable());
        }

        Thread.sleep(10000);

        //whenever you want them to stop
        exec.shutdownNow();

    }   

}

class ProcessRunnable implements Runnable{
       @Override
       public void run(){
        do{
           Process p;
        try {
            p = Runtime.getRuntime().exec("cd ..");
            p.waitFor(); 
        } catch (IOException e) {
                    //Take appropriate steps
            e.printStackTrace();
        } catch (InterruptedException e) {
                    //Take appropriate steps
            e.printStackTrace();
        }

        }while(!Thread.interrupted());
       }
}

Processus#waitFor()

Le thread actuel attendre, si nécessaire, jusqu'à ce que le processus de
représenté par cet objet Processus a pris fin. Cette méthode retourne
immédiatement si le sous-processus est déjà terminé. Si l'
sous-processus n'est pas encore terminée, le thread sera bloqué
jusqu'à ce que le sous-processus des sorties.

Merci pour la Réponse immédiate .J'ai essayé cette approche avec un pool de threads nombre de 4 , mais l'exécution se termine après le lancement et l'achèvement de 4 processus . Les Threads ne sont pas appelés post le 4 processus . Toutes les suggestions
J'ai édité le code pour inclure le code qui fonctionne pour moi. Le 4 threads continuellement les processus et dès qu'il quitte le thread s'exécute à nouveau dans la boucle while jusqu'à ce que vous appelez shutdownNow()

OriginalL'auteur Narendra Pathai

Vous pouvez utiliser fixe le pool de threads avec la taille 4, qui garantit plus de 4 threads actifs à un moment donné

    final ExecutorService ex = Executors.newFixedThreadPool(4);
    for(int i = 0; i < 100; i++) {
        ex.execute(new Runnable() {
            @Override
            public void run() {
              ... run the process here and wait for it to end
            }
        });
    }

OriginalL'auteur Evgeniy Dorofeev

Vous devez vous connecter pour publier un commentaire.