Come si eseguono più programmi in parallelo da uno script bash?

Sto cercando di scrivere a file .sh che esegue molti programmi contemporaneamente

Ci ho provato

prog1 
prog2

Ma quello esegue prog1 quindi attende fino a quando prog1 termina e quindi inizia prog2 ...

Quindi, come posso eseguirli in parallelo?

prog1 &
prog2 &

Che ne dite di:

prog1 & prog2 && fg

Questo sarà:

1. Inizio prog1.
2. Invialo in background, ma continua a stampare il suo output.
3. Inizia prog2e tienilo in primo piano , così puoi chiuderlo con ctrl-c.
4. Quando si chiude prog2, si tornerà a prog1's in primo piano , in modo da poter anche vicino con ctrl-c.

Puoi usare wait:

some_command &
P1=$!
other_command &
P2=$!
wait $P1 $P2

Assegna i PID del programma in background alle variabili ( $!è l'ultimo PID del processo avviato), quindi il waitcomando li attende. È bello perché se uccidi lo script, uccide anche i processi!

Con GNU Parallel http://www.gnu.org/software/parallel/ è facile come:

(echo prog1; echo prog2) | parallel

O se preferisci:

parallel ::: prog1 prog2

Per saperne di più:

• Guarda il video introduttivo per una rapida introduzione: https://www.youtube.com/playlist?list=PL284C9FF2488BC6D1
• Cammina attraverso il tutorial (man parallel_tutorial). La tua riga di comando ti adorerà per questo.
• Leggi: Ole Tange, GNU Parallel 2018 (Ole Tange, 2018).

Se vuoi essere in grado di eseguire facilmente e uccidere più processi con ctrl-c, questo è il mio metodo preferito: spawn più processi in background in una (…)subshell e trap SIGINTda eseguire kill 0, che ucciderà tutto ciò che è generato nel gruppo subshell:

(trap 'kill 0' SIGINT; prog1 & prog2 & prog3)

Puoi avere strutture di esecuzione del processo complesse e tutto si chiuderà con un singolo ctrl-c(assicurati solo che l'ultimo processo sia eseguito in primo piano, cioè non includere un &after prog1.3):

(trap 'kill 0' SIGINT; prog1.1 && prog1.2 & (prog2.1 | prog2.2 || prog2.3) & prog1.3)

xargs -P <n>ti permette di eseguire <n>comandi in parallelo.

Mentre -P sia un'opzione non standard, entrambe le implementazioni GNU (Linux) e macOS / BSD la supportano.

Il seguente esempio:

• corre al massimo 3 comandi in parallelo alla volta,
• con comandi aggiuntivi che iniziano solo quando termina un processo precedentemente avviato.

time xargs -P 3 -I {} sh -c 'eval "$1"' - {} <<'EOF'
sleep 1; echo 1
sleep 2; echo 2
sleep 3; echo 3
echo 4
EOF

L'output è simile al seguente:

1   # output from 1st command 
4   # output from *last* command, which started as soon as the count dropped below 3
2   # output from 2nd command
3   # output from 3rd command

real    0m3.012s
user    0m0.011s
sys 0m0.008s

Il tempismo mostra che i comandi sono stati eseguiti in parallelo (l'ultimo comando è stato lanciato solo dopo che il primo dei 3 originali era terminato, ma eseguito molto rapidamente).

Il xargscomando stesso non verrà restituito fino al termine di tutti i comandi, ma è possibile eseguirlo in background terminandolo con l'operatore di controllo &e quindi utilizzando il waitcomando incorporato per attendere il completamento dell'intero xargscomando.

{
  xargs -P 3 -I {} sh -c 'eval "$1"' - {} <<'EOF'
sleep 1; echo 1
sleep 2; echo 2
sleep 3; echo 3
echo 4
EOF
} &

# Script execution continues here while `xargs` is running 
# in the background.
echo "Waiting for commands to finish..."

# Wait for `xargs` to finish, via special variable $!, which contains
# the PID of the most recently started background process.
wait $!

Nota:

• BSD / macOS xargsrichiede di specificare il conteggio dei comandi da eseguire in parallelo in modo esplicito , mentre GNU xargsconsente di specificare -P 0l'esecuzione del maggior numero possibile in parallelo.

• L'output dei processi eseguiti in parallelo arriva man mano che viene generato , quindi verrà intercalato in modo imprevedibile .

  • GNU parallel, come menzionato nella risposta di Ole (non viene fornito di serie con la maggior parte delle piattaforme), serializza (raggruppa) l'output in base al processo e offre molte altre funzionalità avanzate.

#!/bin/bash
prog1 & 2> .errorprog1.log; prog2 & 2> .errorprog2.log

Reindirizzare gli errori a registri separati.

C'è un programma molto utile che chiama nohup.

     nohup - run a command immune to hangups, with output to a non-tty

Ecco una funzione che uso per eseguire al massimo n processo in parallelo (n = 4 nell'esempio):

max_children=4

function parallel {
  local time1=$(date +"%H:%M:%S")
  local time2=""

  # for the sake of the example, I'm using $2 as a description, you may be interested in other description
  echo "starting $2 ($time1)..."
  "$@" && time2=$(date +"%H:%M:%S") && echo "finishing $2 ($time1 -- $time2)..." &

  local my_pid=$$
  local children=$(ps -eo ppid | grep -w $my_pid | wc -w)
  children=$((children-1))
  if [[ $children -ge $max_children ]]; then
    wait -n
  fi
}

parallel sleep 5
parallel sleep 6
parallel sleep 7
parallel sleep 8
parallel sleep 9
wait

Se max_children è impostato sul numero di core, questa funzione tenterà di evitare i core inattivi.

Puoi provare i pps . ppss è piuttosto potente: puoi persino creare un mini-cluster. xargs -P può anche essere utile se hai una serie di elaborazioni parallele imbarazzanti da fare.

Recentemente ho avuto una situazione simile in cui avevo bisogno di eseguire più programmi contemporaneamente, reindirizzare i loro output su file di registro separati e aspettare che finissero e ho finito con qualcosa del genere:

#!/bin/bash

# Add the full path processes to run to the array
PROCESSES_TO_RUN=("/home/joao/Code/test/prog_1/prog1" \
                  "/home/joao/Code/test/prog_2/prog2")
# You can keep adding processes to the array...

for i in ${PROCESSES_TO_RUN[@]}; do
    ${i%/*}/./${i##*/} > ${i}.log 2>&1 &
    # ${i%/*} -> Get folder name until the /
    # ${i##*/} -> Get the filename after the /
done

# Wait for the processes to finish
wait

Fonte: http://joaoperibeiro.com/execute-multiple-programs-and-redirect-their-outputs-linux/

Responsabile di spawn dei processi

Certo, tecnicamente si tratta di processi, e questo programma dovrebbe davvero essere chiamato un gestore di spawn dei processi, ma questo è dovuto solo al modo in cui BASH funziona quando si biforca usando la e commerciale, usa la chiamata di sistema fork () o forse clone () che clona in uno spazio di memoria separato, piuttosto che qualcosa come pthread_create () che condividerebbe la memoria. Se BASH supportasse quest'ultimo, ogni "sequenza di esecuzione" funzionerebbe esattamente allo stesso modo e potrebbe essere definita come thread tradizionale ottenendo un footprint di memoria più efficiente. Funzionalmente tuttavia funziona allo stesso modo, anche se un po 'più difficile poiché le variabili GLOBAL non sono disponibili in ciascun clone di lavoro, quindi l'uso del file di comunicazione tra processi e il semaforo rudimentale del gregge per gestire le sezioni critiche. Il fork di BASH ovviamente è la risposta di base qui, ma mi sento come se la gente lo sapesse, ma sta davvero cercando di gestire ciò che viene generato piuttosto che semplicemente fork e dimenticarlo. Questo dimostra un modo per gestire fino a 200 istanze di processi biforcati che accedono tutti a una singola risorsa. Chiaramente questo è eccessivo, ma mi è piaciuto scriverlo, quindi ho continuato. Aumenta le dimensioni del tuo terminale di conseguenza. Spero che lo trovi utile

ME=$(basename $0)
IPC="/tmp/$ME.ipc"      #interprocess communication file (global thread accounting stats)
DBG=/tmp/$ME.log
echo 0 > $IPC           #initalize counter
F1=thread
SPAWNED=0
COMPLETE=0
SPAWN=1000              #number of jobs to process
SPEEDFACTOR=1           #dynamically compensates for execution time
THREADLIMIT=50          #maximum concurrent threads
TPS=1                   #threads per second delay
THREADCOUNT=0           #number of running threads
SCALE="scale=5"         #controls bc's precision
START=$(date +%s)       #whence we began
MAXTHREADDUR=6         #maximum thread life span - demo mode

LOWER=$[$THREADLIMIT*100*90/10000]   #90% worker utilization threshold
UPPER=$[$THREADLIMIT*100*95/10000]   #95% worker utilization threshold
DELTA=10                             #initial percent speed change

threadspeed()        #dynamically adjust spawn rate based on worker utilization
{
   #vaguely assumes thread execution average will be consistent
   THREADCOUNT=$(threadcount)
   if [ $THREADCOUNT -ge $LOWER ] && [ $THREADCOUNT -le $UPPER ] ;then
      echo SPEED HOLD >> $DBG
      return
   elif [ $THREADCOUNT -lt $LOWER ] ;then
      #if maxthread is free speed up
      SPEEDFACTOR=$(echo "$SCALE;$SPEEDFACTOR*(1-($DELTA/100))"|bc)
      echo SPEED UP $DELTA%>> $DBG
   elif [ $THREADCOUNT -gt $UPPER ];then
      #if maxthread is active then slow down
      SPEEDFACTOR=$(echo "$SCALE;$SPEEDFACTOR*(1+($DELTA/100))"|bc)
      DELTA=1                            #begin fine grain control
      echo SLOW DOWN $DELTA%>> $DBG
   fi

   echo SPEEDFACTOR $SPEEDFACTOR >> $DBG

   #average thread duration   (total elapsed time / number of threads completed)
   #if threads completed is zero (less than 100), default to maxdelay/2  maxthreads

   COMPLETE=$(cat $IPC)

   if [ -z $COMPLETE ];then
      echo BAD IPC READ ============================================== >> $DBG
      return
   fi

   #echo Threads COMPLETE $COMPLETE >> $DBG
   if [ $COMPLETE -lt 100 ];then
      AVGTHREAD=$(echo "$SCALE;$MAXTHREADDUR/2"|bc)
   else
      ELAPSED=$[$(date +%s)-$START]
      #echo Elapsed Time $ELAPSED >> $DBG
      AVGTHREAD=$(echo "$SCALE;$ELAPSED/$COMPLETE*$THREADLIMIT"|bc)
   fi
   echo AVGTHREAD Duration is $AVGTHREAD >> $DBG

   #calculate timing to achieve spawning each workers fast enough
   # to utilize threadlimit - average time it takes to complete one thread / max number of threads
   TPS=$(echo "$SCALE;($AVGTHREAD/$THREADLIMIT)*$SPEEDFACTOR"|bc)
   #TPS=$(echo "$SCALE;$AVGTHREAD/$THREADLIMIT"|bc)  # maintains pretty good
   #echo TPS $TPS >> $DBG

}
function plot()
{
   echo -en \\033[${2}\;${1}H

   if [ -n "$3" ];then
         if [[ $4 = "good" ]];then
            echo -en "\\033[1;32m"
         elif [[ $4 = "warn" ]];then
            echo -en "\\033[1;33m"
         elif [[ $4 = "fail" ]];then
            echo -en "\\033[1;31m"
         elif [[ $4 = "crit" ]];then
            echo -en "\\033[1;31;4m"
         fi
   fi
      echo -n "$3"
      echo -en "\\033[0;39m"
}

trackthread()   #displays thread status
{
   WORKERID=$1
   THREADID=$2
   ACTION=$3    #setactive | setfree | update
   AGE=$4

   TS=$(date +%s)

   COL=$[(($WORKERID-1)/50)*40]
   ROW=$[(($WORKERID-1)%50)+1]

   case $ACTION in
      "setactive" )
         touch /tmp/$ME.$F1$WORKERID  #redundant - see main loop
         #echo created file $ME.$F1$WORKERID >> $DBG
         plot $COL $ROW "Worker$WORKERID: ACTIVE-TID:$THREADID INIT    " good
         ;;
      "update" )
         plot $COL $ROW "Worker$WORKERID: ACTIVE-TID:$THREADID AGE:$AGE" warn
         ;;
      "setfree" )
         plot $COL $ROW "Worker$WORKERID: FREE                         " fail
         rm /tmp/$ME.$F1$WORKERID
         ;;
      * )

      ;;
   esac
}

getfreeworkerid()
{
   for i in $(seq 1 $[$THREADLIMIT+1])
   do
      if [ ! -e /tmp/$ME.$F1$i ];then
         #echo "getfreeworkerid returned $i" >> $DBG
         break
      fi
   done
   if [ $i -eq $[$THREADLIMIT+1] ];then
      #echo "no free threads" >> $DBG
      echo 0
      #exit
   else
      echo $i
   fi
}

updateIPC()
{
   COMPLETE=$(cat $IPC)        #read IPC
   COMPLETE=$[$COMPLETE+1]     #increment IPC
   echo $COMPLETE > $IPC       #write back to IPC
}


worker()
{
   WORKERID=$1
   THREADID=$2
   #echo "new worker WORKERID:$WORKERID THREADID:$THREADID" >> $DBG

   #accessing common terminal requires critical blocking section
   (flock -x -w 10 201
      trackthread $WORKERID $THREADID setactive
   )201>/tmp/$ME.lock

   let "RND = $RANDOM % $MAXTHREADDUR +1"

   for s in $(seq 1 $RND)               #simulate random lifespan
   do
      sleep 1;
      (flock -x -w 10 201
         trackthread $WORKERID $THREADID update $s
      )201>/tmp/$ME.lock
   done

   (flock -x -w 10 201
      trackthread $WORKERID $THREADID setfree
   )201>/tmp/$ME.lock

   (flock -x -w 10 201
      updateIPC
   )201>/tmp/$ME.lock
}

threadcount()
{
   TC=$(ls /tmp/$ME.$F1* 2> /dev/null | wc -l)
   #echo threadcount is $TC >> $DBG
   THREADCOUNT=$TC
   echo $TC
}

status()
{
   #summary status line
   COMPLETE=$(cat $IPC)
   plot 1 $[$THREADLIMIT+2] "WORKERS $(threadcount)/$THREADLIMIT  SPAWNED $SPAWNED/$SPAWN  COMPLETE $COMPLETE/$SPAWN SF=$SPEEDFACTOR TIMING=$TPS"
   echo -en '\033[K'                   #clear to end of line
}

function main()
{
   while [ $SPAWNED -lt $SPAWN ]
   do
      while [ $(threadcount) -lt $THREADLIMIT ] && [ $SPAWNED -lt $SPAWN ]
      do
         WID=$(getfreeworkerid)
         worker $WID $SPAWNED &
         touch /tmp/$ME.$F1$WID    #if this loops faster than file creation in the worker thread it steps on itself, thread tracking is best in main loop
         SPAWNED=$[$SPAWNED+1]
         (flock -x -w 10 201
            status
         )201>/tmp/$ME.lock
         sleep $TPS
        if ((! $[$SPAWNED%100]));then
           #rethink thread timing every 100 threads
           threadspeed
        fi
      done
      sleep $TPS
   done

   while [ "$(threadcount)" -gt 0 ]
   do
      (flock -x -w 10 201
         status
      )201>/tmp/$ME.lock
      sleep 1;
   done

   status
}

clear
threadspeed
main
wait
status
echo

Il tuo script dovrebbe apparire come:

prog1 &
prog2 &
.
.
progn &
wait
progn+1 &
progn+2 &
.
.

Supponendo che il sistema possa richiedere n lavori alla volta. usare wait per eseguire solo n lavori alla volta.

Con bashj ( https://sourceforge.net/projects/bashj/ ), dovresti essere in grado di eseguire non solo più processi (come suggerito da altri) ma anche più thread in una JVM controllata dal tuo script. Ma ovviamente questo richiede un JDK Java. I thread consumano meno risorse dei processi.

Ecco un codice funzionante:

#!/usr/bin/bashj

#!java

public static int cnt=0;

private static void loop() {u.p("java says cnt= "+(cnt++));u.sleep(1.0);}

public static void startThread()
{(new Thread(() ->  {while (true) {loop();}})).start();}

#!bashj

j.startThread()

while [ j.cnt -lt 4 ]
do
  echo "bash views cnt=" j.cnt
  sleep 0.5
done