bash - programas - sentencias de control en shell script

¿Cómo esperar en bash varios subprocesos para finalizar y devolver el código de salida!=0 cuando cualquier subproceso termina con el código!=0?

Question

¿Cómo esperar en un script de bash varios subprocesos generados a partir de ese script para finalizar y devolver el código de salida! = 0 cuando cualquiera de los subprocesos termina con el código! = 0?

Guión simple:

#!/bin/bash
for i in `seq 0 9`; do
  doCalculations $i &
done
wait

La secuencia de comandos anterior esperará a los 10 subprocesos generados, pero siempre dará el estado de salida 0 (ver help wait ). ¿Cómo puedo modificar este script para que descubra los estados de salida de los subprocesos generados y devuelva el código de salida 1 cuando cualquiera de los subprocesos termina con el código! = 0?

¿Hay alguna solución mejor para eso que recolectar los PID de los subprocesos, esperarlos en orden y sumar los estados de salida?

Answer 1

¿Qué tal simplemente?

#!/bin/bash

pids=""

for i in `seq 0 9`; do
   doCalculations $i &
   pids="$pids $!"
done

wait $pids

...code continued here ...

Actualizar:

Como lo señalaron varios comentaristas, lo anterior espera a que se completen todos los procesos antes de continuar, pero no sale y falla si uno de ellos falla, se puede hacer que se haga con la siguiente modificación sugerida por @Bryan, @SamBrightman y otros :

#!/bin/bash

pids=""
RESULT=0


for i in `seq 0 9`; do
   doCalculations $i &
   pids="$pids $!"
done

for pid in $pids; do
    wait $pid || let "RESULT=1"
done

if [ "$RESULT" == "1" ];
    then
       exit 1
fi

...code continued here ...

Answer 2

Acabo de modificar un script para poner en segundo plano y paralelizar un proceso.

Hice algunos experimentos (en Solaris con bash y ksh) y descubrí que ''esperar'' genera el estado de salida si no es cero, o una lista de trabajos que devuelven una salida distinta de cero cuando no se proporciona un argumento PID. P.ej

Golpetazo:

$ sleep 20 && exit 1 &
$ sleep 10 && exit 2 &
$ wait
[1]-  Exit 2                  sleep 20 && exit 2
[2]+  Exit 1                  sleep 10 && exit 1

Ksh:

$ sleep 20 && exit 1 &
$ sleep 10 && exit 2 &
$ wait
[1]+  Done(2)                  sleep 20 && exit 2
[2]+  Done(1)                  sleep 10 && exit 1

Esta salida se escribe en stderr, por lo que una solución simple para el ejemplo de OP podría ser:

#!/bin/bash

trap "rm -f /tmp/x.$$" EXIT

for i in `seq 0 9`; do
  doCalculations $i &
done

wait 2> /tmp/x.$$
if [ `wc -l /tmp/x.$$` -gt 0 ] ; then
  exit 1
fi

Mientras esto:

wait 2> >(wc -l)

También devolverá un conteo pero sin el archivo tmp. Esto también podría ser usado de esta manera, por ejemplo:

wait 2> >(if [ `wc -l` -gt 0 ] ; then echo "ERROR"; fi)

Pero esto no es mucho más útil que el archivo tmp IMO. No pude encontrar una manera útil de evitar el archivo tmp y, al mismo tiempo, evitar ejecutar la "espera" en un subshell, que no funciona en absoluto.

Answer 3

Aquí está el ejemplo simple usando la wait .

Ejecutar algunos procesos:

$ sleep 10 &
$ sleep 10 &
$ sleep 20 &
$ sleep 20 &

Luego espere con el comando de wait :

$ wait < <(jobs -p)

^{O simplemente wait (sin argumentos) a todos.}

Esto esperará a que se completen todos los trabajos en segundo plano.

^{Si se proporciona la opción -n , espera a que finalice el siguiente trabajo y devuelve su estado de salida.}

Ver: help wait y help jobs para la sintaxis.

Sin embargo, el inconveniente es que esto devolverá solo el estado de la última ID, por lo que debe verificar el estado de cada subproceso y almacenarlo en la variable.

O haga su función de cálculo para crear algún archivo en caso de falla (vacío o con registro de falla), luego verifique ese archivo si existe, por ejemplo

$ sleep 20 && true || tee fail &
$ sleep 20 && false || tee fail &
$ wait < <(jobs -p)
$ test -f fail && echo Calculation failed.

Answer 4

Aquí está mi versión que funciona para varios pids, registra advertencias si la ejecución demora demasiado y detiene los subprocesos si la ejecución demora más que un valor determinado.

function WaitForTaskCompletion {
    local pids="${1}" # pids to wait for, separated by semi-colon
    local soft_max_time="${2}" # If execution takes longer than $soft_max_time seconds, will log a warning, unless $soft_max_time equals 0.
    local hard_max_time="${3}" # If execution takes longer than $hard_max_time seconds, will stop execution, unless $hard_max_time equals 0.
    local caller_name="${4}" # Who called this function
    local exit_on_error="${5:-false}" # Should the function exit program on subprocess errors       

    Logger "${FUNCNAME[0]} called by [$caller_name]."

    local soft_alert=0 # Does a soft alert need to be triggered, if yes, send an alert once 
    local log_ttime=0 # local time instance for comparaison

    local seconds_begin=$SECONDS # Seconds since the beginning of the script
    local exec_time=0 # Seconds since the beginning of this function

    local retval=0 # return value of monitored pid process
    local errorcount=0 # Number of pids that finished with errors

    local pidCount # number of given pids

    IFS='';'' read -a pidsArray <<< "$pids"
    pidCount=${#pidsArray[@]}

    while [ ${#pidsArray[@]} -gt 0 ]; do
        newPidsArray=()
        for pid in "${pidsArray[@]}"; do
            if kill -0 $pid > /dev/null 2>&1; then
                newPidsArray+=($pid)
            else
                wait $pid
                result=$?
                if [ $result -ne 0 ]; then
                    errorcount=$((errorcount+1))
                    Logger "${FUNCNAME[0]} called by [$caller_name] finished monitoring [$pid] with exitcode [$result]."
                fi
            fi
        done

        ## Log a standby message every hour
        exec_time=$(($SECONDS - $seconds_begin))
        if [ $((($exec_time + 1) % 3600)) -eq 0 ]; then
            if [ $log_ttime -ne $exec_time ]; then
                log_ttime=$exec_time
                Logger "Current tasks still running with pids [${pidsArray[@]}]."
            fi
        fi

        if [ $exec_time -gt $soft_max_time ]; then
            if [ $soft_alert -eq 0 ] && [ $soft_max_time -ne 0 ]; then
                Logger "Max soft execution time exceeded for task [$caller_name] with pids [${pidsArray[@]}]."
                soft_alert=1
                SendAlert

            fi
            if [ $exec_time -gt $hard_max_time ] && [ $hard_max_time -ne 0 ]; then
                Logger "Max hard execution time exceeded for task [$caller_name] with pids [${pidsArray[@]}]. Stopping task execution."
                kill -SIGTERM $pid
                if [ $? == 0 ]; then
                    Logger "Task stopped successfully"
                else
                    errrorcount=$((errorcount+1))
                fi
            fi
        fi

        pidsArray=("${newPidsArray[@]}")
        sleep 1
    done

    Logger "${FUNCNAME[0]} ended for [$caller_name] using [$pidCount] subprocesses with [$errorcount] errors."
    if [ $exit_on_error == true ] && [ $errorcount -gt 0 ]; then
        Logger "Stopping execution."
        exit 1337
    else
        return $errorcount
    fi
}

# Just a plain stupid logging function to replace with yours
function Logger {
    local value="${1}"

    echo $value
}

Por ejemplo, espere a que terminen los tres procesos, registre una advertencia si la ejecución demora más de 5 segundos, detenga todos los procesos si la ejecución demora más de 120 segundos. No salga del programa en caso de fallas.

function something {

    sleep 10 &
    pids="$!"
    sleep 12 &
    pids="$pids;$!"
    sleep 9 &
    pids="$pids;$!"

    WaitForTaskCompletion $pids 5 120 ${FUNCNAME[0]} false
}
# Launch the function
someting

Answer 5

Creo que la forma más sencilla de ejecutar trabajos en paralelo y verificar el estado es usar archivos temporales. Ya hay un par de respuestas similares (por ejemplo, Nietzche-jou y mug896).

#!/bin/bash
rm -f fail
for i in `seq 0 9`; do
  doCalculations $i || touch fail &
done
wait 
! [ -f fail ]

El código anterior no es seguro para subprocesos. Si le preocupa que el código anterior se ejecute al mismo tiempo que el mismo, es mejor usar un nombre de archivo más exclusivo, como fail. $$. La última línea es para cumplir el requisito: "devolver el código de salida 1 cuando cualquiera de los subprocesos termina con el código! = 0?" Tiré un requisito adicional allí para limpiar. Puede haber sido más claro escribirlo así:

#!/bin/bash
trap ''rm -f fail.$$'' EXIT
for i in `seq 0 9`; do
  doCalculations $i || touch fail.$$ &
done
wait 
! [ -f fail.$$ ] 

Aquí hay un fragmento similar para recopilar resultados de varios trabajos: creo un directorio temporal, cuento los resultados de todas las sub tareas en un archivo separado y luego las vuelco para revisarlas. Esto realmente no coincide con la pregunta, lo estoy lanzando como un bono:

#!/bin/bash
trap ''rm -fr $WORK'' EXIT

WORK=/tmp/$$.work
mkdir -p $WORK
cd $WORK

for i in `seq 0 9`; do
  doCalculations $i >$i.result &
done
wait 
grep $ *  # display the results with filenames and contents

Answer 6

El siguiente código esperará a que se completen todos los cálculos y devolverá el estado de salida 1 si falla alguno de los cálculos de DoCalculations .

#!/bin/bash
for i in $(seq 0 9); do
   (doCalculations $i >&2 & wait %1; echo $?) &
done | grep -qv 0 && exit 1

Answer 7

Es posible que la señal de captura de CHLD no funcione porque puede perder algunas señales si llegan simultáneamente.

#!/bin/bash

trap ''rm -f $tmpfile'' EXIT

tmpfile=$(mktemp)

doCalculations() {
    echo start job $i...
    sleep $((RANDOM % 5)) 
    echo ...end job $i
    exit $((RANDOM % 10))
}

number_of_jobs=10

for i in $( seq 1 $number_of_jobs )
do
    ( trap "echo job$i : exit value : /$? >> $tmpfile" EXIT; doCalculations ) &
done

wait 

i=0
while read res; do
    echo "$res"
    let i++
done < "$tmpfile"

echo $i jobs done !!!

Answer 8

Esto es lo que he encontrado hasta ahora. Me gustaría ver cómo interrumpir el comando de suspensión si un niño termina, para que uno no tenga que ajustar WAITALL_DELAY al uso de uno.

waitall() { # PID...
  ## Wait for children to exit and indicate whether all exited with 0 status.
  local errors=0
  while :; do
    debug "Processes remaining: $*"
    for pid in "$@"; do
      shift
      if kill -0 "$pid" 2>/dev/null; then
        debug "$pid is still alive."
        set -- "$@" "$pid"
      elif wait "$pid"; then
        debug "$pid exited with zero exit status."
      else
        debug "$pid exited with non-zero exit status."
        ((++errors))
      fi
    done
    (("$#" > 0)) || break
    # TODO: how to interrupt this sleep when a child terminates?
    sleep ${WAITALL_DELAY:-1}
   done
  ((errors == 0))
}

debug() { echo "DEBUG: $*" >&2; }

pids=""
for t in 3 5 4; do 
  sleep "$t" &
  pids="$pids $!"
done
waitall $pids

Answer 9

Esto funciona, ¡debería ser tan bueno, si no mejor, que la respuesta de @HoverHell!

#!/usr/bin/env bash

set -m # allow for job control
EXIT_CODE=0;  # exit code of overall script

function foo() {
     echo "CHLD exit code is $1"
     echo "CHLD pid is $2"
     echo $(jobs -l)

     for job in `jobs -p`; do
         echo "PID => ${job}"
         wait ${job} ||  echo "At least one test failed with exit code => $?" ; EXIT_CODE=1
     done
}

trap ''foo $? $$'' CHLD

DIRN=$(dirname "$0");

commands=(
    "{ echo "foo" && exit 4; }"
    "{ echo "bar" && exit 3; }"
    "{ echo "baz" && exit 5; }"
)

clen=`expr "${#commands[@]}" - 1` # get length of commands - 1

for i in `seq 0 "$clen"`; do
    (echo "${commands[$i]}" | bash) &   # run the command via bash in subshell
    echo "$i ith command has been issued as a background job"
done

# wait for all to finish
wait;

echo "EXIT_CODE => $EXIT_CODE"
exit "$EXIT_CODE"

# end

y, por supuesto, he inmortalizado este script, en un proyecto NPM que le permite ejecutar comandos de bash en paralelo, útil para probar:

https://github.com/ORESoftware/generic-subshell

Answer 10

Estoy pensando que tal vez ejecute doCalculations; echo "$?" >> / tmp / acc en una subshell que se envía al fondo, luego la espera, luego / tmp / acc contendría los estados de salida, uno por línea. Sin embargo, no conozco las consecuencias de los múltiples procesos que se agregan al archivo del acumulador.

Aquí hay una prueba de esta sugerencia:

Archivo: doCalcualtions

#!/bin/sh random -e 20 sleep $? random -e 10

Archivo: intentar

#!/bin/sh rm /tmp/acc for i in $( seq 0 20 ) do ( ./doCalculations "$i"; echo "$?" >>/tmp/acc ) & done wait cat /tmp/acc | fmt rm /tmp/acc

Salida de ejecución ./try

5 1 9 6 8 1 2 0 9 6 5 9 6 0 0 4 9 5 5 9 8

Answer 11

He intentado esto y he combinado todas las mejores partes de los otros ejemplos aquí. Esta secuencia de comandos ejecutará la función checkpids cuando checkpids cualquier proceso en segundo plano y checkpids el estado de salida sin recurrir a sondeo.

#!/bin/bash

set -o monitor

sleep 2 &
sleep 4 && exit 1 &
sleep 6 &

pids=`jobs -p`

checkpids() {
    for pid in $pids; do
        if kill -0 $pid 2>/dev/null; then
            echo $pid is still alive.
        elif wait $pid; then
            echo $pid exited with zero exit status.
        else
            echo $pid exited with non-zero exit status.
        fi
    done
    echo
}

trap checkpids CHLD

wait

Answer 12

La solución para esperar varios subprocesos y para salir cuando alguno de ellos sale con un código de estado distinto de cero es mediante el uso de ''wait -n''

#!/bin/bash
wait_for_pids()
{
    for (( i = 1; i <= $#; i++ )) do
        wait -n $@
        status=$?
        echo "received status: "$status
        if [ $status -ne 0 ] && [ $status -ne 127 ]; then
            exit 1
        fi
    done
}

sleep_for_10()
{
    sleep 10
    exit 10
}

sleep_for_20()
{
    sleep 20
}

sleep_for_10 &
pid1=$!

sleep_for_20 &
pid2=$!

wait_for_pids $pid2 $pid1

El código de estado ''127'' es para un proceso que no existe, lo que significa que el hijo podría haber salido.

Answer 13

Necesitaba esto, pero el proceso de destino no era un hijo del shell actual, en cuyo caso, la wait $PID no funciona. Encontré la siguiente alternativa en su lugar:

while [ -e /proc/$PID ]; do sleep 0.1 ; done

Eso depende de la presencia de procfs , que puede no estar disponible (Mac no lo proporciona, por ejemplo). Así que para la portabilidad, podrías usar esto en su lugar:

while ps -p $PID >/dev/null ; do sleep 0.1 ; done

Answer 14

No creo que sea posible con la funcionalidad incorporada de Bash.

Puede recibir una notificación cuando un niño sale:

#!/bin/sh
set -o monitor        # enable script job control
trap ''echo "child died"'' CHLD

Sin embargo, no hay una forma aparente de obtener el estado de salida del niño en el controlador de señales.

Obtener ese estado secundario suele ser el trabajo de la familia de funciones de wait en las API POSIX de nivel inferior. Desafortunadamente, el soporte de Bash para eso es limitado: puede esperar un proceso secundario específico (y obtener su estado de salida) o puede esperar a todos y obtener siempre un resultado de 0.

Lo que parece imposible de hacer es el equivalente de waitpid(-1) , que bloquea hasta que se devuelve cualquier proceso secundario.

Answer 15

Para paralelizar esto ...

for i in $(whatever_list) ; do
   do_something $i
done

Traducir a esto ...

for i in $(whatever_list) ; do echo $i ; done | ## execute in parallel...
   (
   export -f do_something ## export functions (if needed)
   export PATH ## export any variables that are required
   xargs -I{} --max-procs 0 bash -c '' ## process in batches...
      {
      echo "processing {}" ## optional
      do_something {}
      }'' 
   )

• Si ocurre un error en un proceso, no interrumpirá los otros procesos, pero resultará en un código de salida distinto de cero de la secuencia en su totalidad .
• Las funciones y variables de exportación pueden o no ser necesarias, en cualquier caso particular.
• Puede configurar --max-procs según el paralelismo que desee ( 0 significa "todos a la vez").
• GNU Parallel ofrece algunas características adicionales cuando se usa en lugar de xargs , pero no siempre se instala de forma predeterminada.
• El bucle for no es estrictamente necesario en este ejemplo, ya que echo $i es básicamente la regeneración de la salida de $(whatever_list ). Simplemente creo que el uso de la palabra clave for hace que sea un poco más fácil ver lo que está sucediendo.
• El manejo de cadenas de Bash puede ser confuso: he encontrado que usar comillas simples funciona mejor para envolver scripts no triviales.
• Puede interrumpir fácilmente toda la operación (usando ^ C o similar), a diferencia del enfoque más directo al paralelismo de Bash .

Aquí hay un ejemplo de trabajo simplificado ...

for i in {0..5} ; do echo $i ; done |xargs -I{} --max-procs 2 bash -c ''
   {
   echo sleep {}
   sleep 2s
   }''

Answer 16

Puede haber un caso en el que el proceso se complete antes de esperar el proceso. Si desencadenamos la espera de un proceso que ya ha finalizado, generará un error, ya que pid no es un hijo de este shell. Para evitar tales casos, la siguiente función se puede usar para determinar si el proceso está completo o no:

isProcessComplete(){
PID=$1
while [ -e /proc/$PID ]
do
    echo "Process: $PID is still running"
    sleep 5
done
echo "Process $PID has finished"
}

Answer 17

Si tiene disponible bash 4.2 o una versión posterior, lo siguiente podría serle útil. Utiliza matrices asociativas para almacenar nombres de tareas y su "código", así como nombres de tareas y sus pids. También incorporé un método simple de limitación de velocidad que podría ser útil si sus tareas consumen mucha CPU o tiempo de E / S y desea limitar la cantidad de tareas concurrentes.

El script inicia todas las tareas en el primer bucle y consume los resultados en el segundo.

Esto es un poco excesivo para los casos simples pero permite cosas bastante lindas. Por ejemplo, uno puede almacenar mensajes de error para cada tarea en otra matriz asociativa e imprimirlos después de que todo se haya calmado.

#! /bin/bash

main () {
    local -A pids=()
    local -A tasks=([task1]="echo 1"
                    [task2]="echo 2"
                    [task3]="echo 3"
                    [task4]="false"
                    [task5]="echo 5"
                    [task6]="false")
    local max_concurrent_tasks=2

    for key in "${!tasks[@]}"; do
        while [ $(jobs 2>&1 | grep -c Running) -ge "$max_concurrent_tasks" ]; do
            sleep 1 # gnu sleep allows floating point here...
        done
        ${tasks[$key]} &
        pids+=(["$key"]="$!")
    done

    errors=0
    for key in "${!tasks[@]}"; do
        pid=${pids[$key]}
        local cur_ret=0
        if [ -z "$pid" ]; then
            echo "No Job ID known for the $key process" # should never happen
            cur_ret=1
        else
            wait $pid
            cur_ret=$?
        fi
        if [ "$cur_ret" -ne 0 ]; then
            errors=$(($errors + 1))
            echo "$key (${tasks[$key]}) failed."
        fi
    done

    return $errors
}

main

Answer 18

Si tienes instalado GNU Parallel puedes hacer:

# If doCalculations is a function
export -f doCalculations
seq 0 9 | parallel doCalculations {}

GNU Parallel te dará el código de salida:

• 0 - Todos los trabajos se ejecutaron sin error.

• 1-253 - Algunos de los trabajos fallaron. El estado de salida da el número de trabajos fallidos

• 254 - Más de 253 trabajos fallaron.

• 255 - Otro error.

Mire los videos de introducción para obtener más información: http://pi.dk/1

Answer 19

Simplemente almacene los resultados fuera del shell, por ejemplo, en un archivo.

#!/bin/bash
tmp=/tmp/results

: > $tmp  #clean the file

for i in `seq 0 9`; do
  (doCalculations $i; echo $i:$?>>$tmp)&
done      #iterate

wait      #wait until all ready

sort $tmp | grep -v '':0''  #... handle as required

Answer 20

Utilicé esto recientemente (gracias a Alnitak):

#!/bin/bash
# activate child monitoring
set -o monitor

# locking subprocess
(while true; do sleep 0.001; done) &
pid=$!

# count, and kill when all done
c=0
function kill_on_count() {
    # you could kill on whatever criterion you wish for
    # I just counted to simulate bash''s wait with no args
    [ $c -eq 9 ] && kill $pid
    c=$((c+1))
    echo -n ''.'' # async feedback (but you don''t know which one)
}
trap "kill_on_count" CHLD

function save_status() {
    local i=$1;
    local rc=$2;
    # do whatever, and here you know which one stopped
    # but remember, you''re called from a subshell
    # so vars have their values at fork time
}

# care must be taken not to spawn more than one child per loop
# e.g don''t use `seq 0 9` here!
for i in {0..9}; do
    (doCalculations $i; save_status $i $?) &
done

# wait for locking subprocess to be killed
wait $pid
echo

Desde allí, se puede extrapolar fácilmente y tener un disparador (tocar un archivo, enviar una señal) y cambiar los criterios de conteo (contar los archivos tocados, o lo que sea) para responder a ese disparador. O si solo quieres "cualquier" rc cero, simplemente elimina el bloqueo de save_status.

Answer 21

Veo muchos buenos ejemplos enumerados aquí, también quise incluir los míos.

#! /bin/bash

items="1 2 3 4 5 6"
pids=""

for item in $items; do
    sleep $item &
    pids+="$! "
done

for pid in $pids; do
    wait $pid
    if [ $? -eq 0 ]; then
        echo "SUCCESS - Job $pid exited with a status of $?"
    else
        echo "FAILED - Job $pid exited with a status of $?"
    fi
done

Uso algo muy similar para iniciar / detener servidores / servicios en paralelo y comprobar el estado de cada salida. Funciona muy bien para mí. ¡Espero que esto ayude a alguien!

Answer 22

Ya hay muchas respuestas aquí, pero me sorprende que nadie parece haber sugerido el uso de matrices ... Así que esto es lo que hice: esto podría ser útil para algunos en el futuro.

n=10 # run 10 jobs
c=0
PIDS=()

while true

    my_function_or_command &
    PID=$!
    echo "Launched job as PID=$PID"
    PIDS+=($PID)

    (( c+=1 ))

    # required to prevent any exit due to error
    # caused by additional commands run which you
    # may add when modifying this example
    true

do

    if (( c < n ))
    then
        continue
    else
        break
    fi
done 


# collect launched jobs

for pid in "${PIDS[@]}"
do
    wait $pid || echo "failed job PID=$pid"
done

Answer 23

la trampa es tu amiga Usted puede atrapar en ERR en muchos sistemas. Puede interceptar EXIT o en DEBUG para realizar un fragmento de código después de cada comando.

Esto además de todas las señales estándar.

Answer 24

http://jeremy.zawodny.com/blog/archives/010717.html :

#!/bin/bash

FAIL=0

echo "starting"

./sleeper 2 0 &
./sleeper 2 1 &
./sleeper 3 0 &
./sleeper 2 0 &

for job in `jobs -p`
do
echo $job
    wait $job || let "FAIL+=1"
done

echo $FAIL

if [ "$FAIL" == "0" ];
then
echo "YAY!"
else
echo "FAIL! ($FAIL)"
fi

Answer 25

wait también (opcionalmente) toma el PID del proceso a esperar, y con $! obtienes el PID del último comando lanzado en segundo plano. Modifique el bucle para almacenar el PID de cada subproceso generado en una matriz, y luego haga un bucle nuevamente esperando cada PID.

# run processes and store pids in array
for i in $n_procs; do
    ./procs[${i}] &
    pids[${i}]=$!
done

# wait for all pids
for pid in ${pids[*]}; do
    wait $pid
done

Answer 26

#!/bin/bash
set -m
for i in `seq 0 9`; do
  doCalculations $i &
done
while fg; do true; done

• set -m te permite usar fg & bg en un script
• fg , además de poner el último proceso en primer plano, tiene el mismo estado de salida que el proceso en primer plano
• while fg se detendrá cuando cualquier fg salga con un estado de salida distinto de cero

desafortunadamente esto no manejará el caso cuando un proceso en segundo plano sale con un estado de salida distinto de cero. (el bucle no terminará de inmediato. esperará a que se completen los procesos anteriores).

Answer 27

set -e
fail () {
    touch .failure
}
expect () {
    wait
    if [ -f .failure ]; then
        rm -f .failure
        exit 1
    fi
}

sleep 2 || fail &
sleep 2 && false || fail &
sleep 2 || fail
expect

El set -e en la parte superior hace que su script se detenga en caso de error.

expect devolverá 1 si falla alguna sub-tarea.