Ont bash script exécuter plusieurs programmes comme des processus distincts

Comme le suggère le titre, comment puis-je écrire un script bash qui va l'exécuter pour l'exemple 3 différents programmes Python comme des processus distincts? Et puis je suis en mesure d'accéder à chacun de ces processus, pour voir ce qui est enregistré sur le terminal?

Edit: Merci encore. J'ai oublié de mentionner que je suis au courant de l'ajout de & mais je ne suis pas sûr de la façon d'accéder à ce qui est en cours de sortie de la borne pour chaque processus. Par exemple j'ai pu courir tous les 3 de ces programmes séparément sur les différents onglets et être en mesure de voir ce qui est en cours de sortie.

InformationsquelleAutor Petesta | 2013-08-12

11

Vous pouvez exécuter une tâche en arrière-plan comme ceci:
```
command &
```
Cela vous permet de démarrer plusieurs emplois en ligne sans avoir à attendre que la précédente à la fin.

Si vous commencez à plusieurs tâches en arrière-plan comme cela, ils partagent tous la même stdout (et stderr), ce qui signifie que leur sortie est susceptible d'être entrelacés. Prenez, par exemple, le script suivant:
```
#!/bin/bash
# countup.sh

for i in `seq 3`; do
    echo $i
    sleep 1
done
```
Démarrer deux fois en arrière-plan:
```
./countup.sh &
./countup.sh &
```
Et ce que vous voyez dans votre terminal va ressembler à quelque chose comme ceci:
```
1
1
2
2
3
3
```
Mais pourrait aussi ressembler à ceci:
```
1
2
1
3
2
3
```
Vous ne voulez probablement pas, car il serait très difficile de déterminer lequel de sortie appartenait à l'emploi qui. La solution? Rediriger stdout (et éventuellement stderr) pour chaque poste de travail dans un fichier séparé. Par exemple
```
command > file &
```
va rediriger uniquement stdout et
```
command > file 2>&1 &
```
va rediriger les deux stdout et stderr pour command à file lors de l'exécution de command en arrière-plan. Cette page a une bonne introduction à la redirection dans Bash. Vous pouvez afficher la sortie de la commande "live" par tailing le fichier:
```
tail -f file
```
Je recommande l'exécution de tâches en arrière-plan avec nohup ou écran comme user2676075 mentionné à laisser vos travaux de continuer à courir après la fermeture de votre session de terminal, par exemple
```
nohup command1 > file1 2>&1 &
nohup command2 > file2 2>&1 &
nohup command3 > file3 2>&1 &
```
InformationsquelleAutor ThisSuitIsBlackNot
3

Essayez quelque chose comme:
```
command1 2>&1 | tee commandlogs/command1.log ;
command2 2>&1 | tee commandlogs/command2.log ; 
command3 2>&1 | tee commandlogs/command3.log
...
```
Ensuite, vous pouvez la queue les fichiers que l'exécution des commandes. N'oubliez pas, vous pouvez la queue tout en étant dans le répertoire et de faire une "queue *.journal"

Alternativement, vous pouvez configurer un script pour générer un écran pour chaque commande avec:
```
screen -S CMD1 -d -m command1 ;
screen -S CMD2 -d -m command2 ;
screen -S CMD3 -d -m command3
...
```
Puis rebranchez-le pour plus tard avec écran-liste et screen-r [nom de l'écran]

Profiter de

InformationsquelleAutor Alex Atkinson
0

Une autre option est d'utiliser un émulateur de terminal pour exécuter les trois processus. Vous pouvez utiliser xterm (ou rxvt, etc.) si vous êtes à l'aide de X.
```
xterm -e <program1> [arg] ... &
xterm -e <program2> [arg] ... &
xterm -e <program3> [arg] ... &
```
Dépend de ce que vous voulez. Cette approche permet de sortir le terminal de windows, de sorte que vous pouvez voir le résultat en temps réel. Vous pouvez aussi le combiner avec la redirection d'enregistrer le résultat en tant que bien.

InformationsquelleAutor Ziffusion

Vous devez vous connecter pour publier un commentaire.