bash: lancer plusieurs commandes chaînées en arrière-plan

J'essaie de l'exécuter certaines commandes en parallèle, dans le fond, à l'aide de bash. Voici ce que j'essaie de faire:

forloop {
  //this part is actually written in perl
  //call command sequence
  print `touch .file1.lock; cp bigfile1 /destination; rm .file1.lock;`;
}

La partie entre backticks (`) donne naissance à un nouveau shell et exécute les commandes dans la succession. La chose est, le contrôle de l'origine programme renvoie seulement après la dernière commande a été exécutée. Je tiens à exécuter l'intégralité de la déclaration en arrière-plan (je ne suis pas attendre quelque chose en sortie/les valeurs de retour) et je voudrais la boucle pour continuer à fonctionner.

Le programme appelant (celui qui a la boucle) n'aurait pas de fin jusqu'à ce que tous les engendré des coquilles de finition.

Je pourrais utiliser des threads en perl pour frayer les différents threads qui appelle les différentes coquilles, mais il semble inutile...

Puis-je lancer un interpréteur de commandes, de lui donner un ensemble de commandes et dites lui d'aller à l'arrière-plan?

InformationsquelleAutor Mad_Ady | 2008-10-02

29

Je n'ai pas testé cela, mais que diriez -
```
print `(touch .file1.lock; cp bigfile1 /destination; rm .file1.lock;) &`;
```
Les parenthèses signifient exécuter dans un shell interne est exécuté, mais qui ne devrait pas faire de mal.
- Vous ne voulez pas de les imprimer ou de les backticks - même si ces commandes ne donne utile de sortie en cours d'exécution en arrière-plan signifierait que les backticks ne pas le voir
- (Je n'aime pas les backticks de toute façon, je trouve que $() beaucoup plus facile à lire, mais ce n'est pas pertinente ici)
- Merci beaucoup! Il m'a aussi aidé sur un autre problème, avec un script bash, où certains appellent à l'externe des proccess a toujours l'impression de sortie dans stdout même j'ai été à l'aide de "&> /dev/null", mais résolu à l'appel de cette façon: `(./call_the_proccess &> /dev/null) &"
InformationsquelleAutor Hugh Allen

Grâce Hugh, qu'il a fait:

adrianp@frost:~$ (echo "started"; sleep 15; echo "stopped")
started
stopped
adrianp@frost:~$ (echo "started"; sleep 15; echo "stopped") &
started
[1] 7101
adrianp@frost:~$ stopped

[1]+  Done                    ( echo "started"; sleep 15; echo "stopped" )
adrianp@frost:~$

Les autres idées ne fonctionnent pas parce qu'ils commencent chaque commande en arrière-plan, et non pas la séquence de commande (ce qui est important dans mon cas!).

Merci encore!

ne serait pas sleep 3 vous faire économiser un peu de temps dans le débogage?

InformationsquelleAutor Mad_Ady

18

Un autre moyen est d'utiliser la syntaxe suivante:
```
{ command1; command2; command3; } &
wait
```
Noter que le & va à la fin de la commande de groupe, pas après chaque commande. Le point-virgule après la dernière commande est nécessaire, tout comme l'espace après le premier support et avant la finale de support. Le wait à la fin assure que le processus parent n'est pas tué avant la donné naissance à l'enfant (le groupe de commande) se termine.

Vous pouvez aussi faire de la fantaisie des trucs comme la redirection stderr et stdout:
```
{ command1; command2; command3; } 2>&2 1>&1 &
```
Votre exemple serait:
```
forloop() {
    { touch .file1.lock; cp bigfile1 /destination; rm .file1.lock; } &
}
# ... do some other concurrent stuff
wait # wait for childs to end
```
InformationsquelleAutor lechup
14
```
for command in $commands
do
    "$command" &
done
wait
```
L'esperluette à la fin de la commande s'exécute en arrière-plan, et le wait attend jusqu'à ce que la tâche d'arrière-plan est terminé.
- Pas ok becase chaque commande exécuter en arrière-plan, pas de la séquence de commande.
- vous avez besoin d' **commande $** (notez le "$").
- si les commandes qui contiennent des espaces, cela ne fonctionne pas, ils le font habituellement
InformationsquelleAutor GavinCattell
5

GavinCattell obtenu le plus proche (pour bash, OMI), mais comme Mad_Ady l'a souligné, il ne gère pas le "verrouillage" des fichiers. Cela devrait:

Si il y a d'autres emplois dans l'attente, le attendre va attendre pour ceux, trop. Si vous avez besoin d'attendre pour seulement les copies, vous pouvez accumuler les Pid et d'attendre que les. Si pas, vous pouvez supprimer les 3 lignes avec "pid", mais c'est plus général.

En outre, j'ai ajouté de la vérification pour éviter la copie au total:
```
pids=
for file in bigfile*
do
    # Skip if file is not newer...
    targ=/destination/$(basename "${file}")
    [ "$targ" -nt "$file" ] && continue

    # Use a lock file:  ".fileN.lock" for each "bigfileN"
    lock=".${file##*/big}.lock"
    ( touch $lock; cp "$file" "$targ"; rm $lock ) &
    pids="$pids $!"
done
wait $pids
```
D'ailleurs, on dirait que vous êtes la copie des nouveaux fichiers sur un FTP référentiel (ou similaire). Si oui, vous pourrait envisager un copier/renommer stratégie au lieu de les fichiers de verrouillage (mais c'est un autre sujet).

InformationsquelleAutor NVRAM

L'installation de bash que vous cherchez s'appelle Compound Commands. Voir la page de man pour plus d'info:

Composé De Commandes
Un composé de commande est l'une des opérations suivantes:

   (list) list  is  executed  in a subshell environment (see COMMAND EXECUTION ENVIRONMENT below).  Variable assignments and
          builtin commands that affect the shell's environment do not remain in effect after  the  command  completes.   The
          return status is the exit status of list.

   { list; }
          list  is  simply  executed in the current shell environment.  list must be terminated with a newline or semicolon.
          This is known as a group command.  The return status is the exit status of list.  Note that unlike the metacharac‐
          ters  (  and  ),  {  and  } are reserved words and must occur where a reserved word is permitted to be recognized.
          Since they do not cause a word break, they must be separated from list by whitespace or another shell  metacharac‐
          ter.

Il en existe d'autres, mais ce sont probablement les 2 types les plus courants. La première, parens, se déroulera une liste de commande en série dans un shell interne est exécuté, tandis que le second, les accolades, une liste de commandes en série dans le shell courant.

parens

% ( date; sleep 5; date; )
Sat Jan 26 06:52:46 EST 2013
Sat Jan 26 06:52:51 EST 2013

accolades

% { date; sleep 5; date; }
Sat Jan 26 06:52:13 EST 2013
Sat Jan 26 06:52:18 EST 2013

InformationsquelleAutor slm

Exécutez la commande par l'aide à l'emploi:

# date
# jue sep 13 12:43:21 CEST 2012
# at 12:45
warning: commands will be executed using /bin/sh
at> command1
at> command2
at> ...
at> CTRL-d
at> <EOT>
job 20 at Thu Sep 13 12:45:00 2012

Le résultat sera envoyé à votre compte par mail.

InformationsquelleAutor Eliseo Carrasco

2

Je suis tombé sur ce fil de discussion ici et a décidé de mettre un extrait de code pour frayer enchaîné les déclarations en tâche de fond. J'ai testé cela sur BASH pour Linux, KSH pour IBM AIX et Busybox est de la CENDRE pour Android, donc je pense qu'il est sûr de dire qu'il travaille sur tout Bourne-shell.
```
processes=0;
for X in `seq 0 10`; do
   let processes+=1;
   { { echo Job $processes; sleep 3; echo End of job $processes; } & };
   if [[ $processes -eq 5 ]]; then
      wait;
      processes=0;
   fi;
done;
```
Ce code s'exécute un certain nombre de tâches en arrière-plan jusqu'à une certaine limite de connexions simultanées emplois. Vous pouvez l'utiliser, par exemple, pour recompresser beaucoup de format de fichiers avec xz sans avoir un énorme bouquet de xz processus de manger la totalité de votre mémoire et faire de votre ordinateur de vomir: dans ce cas, vous utilisez * comme le forla liste et le travail par lots serait gzip -cd "$X" | xz -9c > "${X%.gz}.xz".
- ne serait pas "xargs" être une solution simple pour ce type de problèmes?
InformationsquelleAutor RAKK
2

exécuter les commandes dans un shell interne est exécuté:
```
(command1 ; command2 ; command3) &
```
InformationsquelleAutor Radu Simionescu
1

Essayer de mettre les commandes dans des accolades avec des &s, comme ceci:
```
{command1 & ; command2 & ; command3 & ; }
```
Ce n'est pas de créer un sous-shell, mais exécute les commandes du groupe en arrière-plan.

HTH
- Mais alors qu'ils vont exécuter en parallèle, ce qui n'est pas ce que l'OP veut!
- Ouais, c'est vrai...
- Les rendements encore une erreur avec mon bash 4.0.33(1)-release / Ubuntu Karmic): $ echo 1 & ; echo 2 bash: erreur de syntaxe près de jeton inattendu `;' $ echo 1 & echo 2 [1] 9466 2 1 [1]+ Fait echo 1 => Vous aurez à utiliser uniquement "&" et omettre le ";".
InformationsquelleAutor Zsolt Botykai
1

Je ne sais pas pourquoi personne n'a répondu avec la solution appropriée:
```
my @children;
for (...) {
    ...
    my $child = fork;
    exec "touch .file1.lock; cp bigfile1 /destination; rm .file1.lock;" if $child == 0;
    push @children, $child;
}
# and if you want to wait for them to finish,
waitpid($_) for @children;
```
Cela provoque Perl pour frayer les enfants à l'exécution de chaque commande, et vous permet d'attendre que tous les enfants avant de poursuivre.

Par la voie,
```
print `some command`
```
et
```
system "some command"
```
sortie le même contenu sur la sortie standard, mais le premier a une hausse des frais généraux, comme Perl a capturer tous "some command"sortie de l'

InformationsquelleAutor ephemient
1

De bifurquer dans une boucle for:

for i in x; do ((a; b; c;)&); done

Exemple:

for i in 500 300 100; do ((printf "Start $i: "; date; dd if=/dev/zero of=testfile_$i bs=1m count=$i 2>/dev/null; printf "End $i: "; date;)&) && sleep 1; done
- Cette solution est bonne quand nous en avons besoin pour exécuter pour la boucle dans la ligne de commande et la nécessité de mettre les commandes à l'intérieur de la boucle à l'arrière du terrain.
InformationsquelleAutor Nikolas Britton
0

Juste au cas où que quelqu'un est toujours intéressé, vous pouvez le faire sans faire appel à un shell interne est exécuté comme ceci:
```
print `touch .file1.lock && cp bigfile1 /destination && rm .file1.lock &`;
```
InformationsquelleAutor Anastasios Andronidis
0

Vous pouvez utiliser GNU parallel commande à exécuter des tâches en parallèle. Il est plus en sécurité au plus vite.

Ma conjecture est que vous essayez de copier plusieurs fichiers volumineux à partir de la source à la destination. Et pour cela, vous pouvez le faire en parallèle avec la déclaration ci-dessous.
```
$ ls *|parallel -kj0 --eta 'cp {} /tmp/destination'
```
Que nous avons utilisé -j0 option, tous les fichiers seront copiés en parallèle. Dans le cas où si vous avez besoin de réduire le nombre de processus en parallèle, alors vous pouvez utiliser -j<n> où <n> est le nombre de processus en parallèle pour être exécuté.

Parallèle permettra également de recueillir la sortie du processus et d'en faire rapport de façon séquentielle (avec -k option), qui d'autre emploi mécanisme de contrôle ne peut pas faire.

--eta option va vous donner les détails de la statistique du processus qui est en cours. Afin que nous puissions savoir comment peut-ont été complétées et combien de temps cela prend-il pour obtenir terminée.

InformationsquelleAutor Kannan Mohan

Vous pouvez passer des paramètres à un groupe de commandes (ayant séquentiel commandes) et de les exécuter en arrière-plan.

for hrNum in {00..11};
do
    oneHour=$((10#$hrNum + 0))
    secondHour=$((10#$hrNum + 12))
    { echo "$oneHour"; echo "$secondHour"; } &
    wait
done

InformationsquelleAutor user7668

Vous devez vous connecter pour publier un commentaire.