Come "combinare" in modo sicuro le linee stampate da più programmi?

Supponiamo che io voglia eseguire più programmi in parallelo e combinare i loro output su una pipe:

sh -c '
    (echo qqq; echo qqq2; echo qqq3)&
    (echo www; echo www2; echo www3)& 
    (echo eee; echo eee2; echo eee3)& 
  wait; wait; wait'

Questo approccio alla shell funziona bene per questo semplice caso, ma mi aspetto che fallisca se i programmi producono più e più linee in modo bufferizzato, come questo (costruito):

qqq
qqwww
q2
qqq3www2

wwweee3

eee2
eee3

Una delle soluzioni che mi è stato suggerito di usare è stata tail -f:

tail -n +0 -q -f <(echo qqq; echo qqq2; echo qqq3) <(echo www; echo www2; echo www3) <(echo eee; echo eee2; echo eee3)

, ma questa è un'opzione non ottimale: genera dati in modo lento, non termina; Vedo le uscite non in ordine di "sospensione", ma in ordine di argomenti in questo caso:

tail -n +0 -q -f <(sleep 1; echo qqq; sleep 1; echo qqq2; echo qqq3) <(echo www; echo www2; sleep 10; echo www3) <(echo eee; sleep 4; echo eee2; echo eee3) | cat

Ho implementato un piccolo programma speciale per questo, ma credo che ci dovrebbe essere un buon modo standard per farlo.

Come farlo utilizzando strumenti standard (e senza tail -fsvantaggi)?

GNU Parallel.

Dalle note di rilascio datate agosto 2013:

--line-bufferbufferizzerà l'output sulla base della linea. --groupmantiene l'output insieme per un intero lavoro. --ungroupconsente il mixup dell'output con mezza riga proveniente da un lavoro e mezza riga proveniente da un altro lavoro. --line-buffersi inserisce tra questi due; stampa una linea intera, ma consentirà di mescolare linee di diversi lavori.

Per esempio:

parallel --line-buffer <jobs

Dove jobscontiene:

./long.sh
./short.sh one
./short.sh two

short.sh:

#!/bin/bash

while true; do
        echo "short line $1"
        sleep .1
done

long.sh:

#!/bin/bash

count=0
while true; do
        echo -n "long line with multiple write()s "
        sleep .1
        count=$((count+1))
        if [ $count -gt 30 ]; then
                count=0
                echo
        fi
done

Produzione:

short line one
short line two
short line one
short line two
short line one
**-snip-**
short line one
short line one
short line two
short line two
short line one
short line one
short line one
long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s long line with multiple write()s 
short line two
short line two
short line two
short line one

Una soluzione che implementa i blocchi:

function putlines () {
   read line || return $?
   while ! ln -s $$ lock >/dev/null 2>&1
   do
      sleep 0.05
   done
   echo "$line" 
}

function getlines () {
     while read lline
     do 
          echo "$lline"
          rm lock
     done
}

# your paralelized jobs  
(  
   job1 | putlines & 
   job2 | putlines & 
   job3 | putlines & 
   wait
) | getlines| final_processing

Dovrebbe esserci un modo più veloce per creare un blocco rispetto all'utilizzo del filesystem.

Non riesco a pensare a niente di semplice, che ti aiuterà, se le tue linee sono così lunghe, che un programma verrà inviato a dormire prima che fosse in grado, di finire di scrivere una linea su stdout.

Tuttavia, se le righe sono abbastanza corte da essere scritte interamente prima della commutazione del processo e il problema è che la generazione di una riga richiede molto tempo, è possibile bufferizzare l'output utilizzando read.

Per esempio:

((./script1 | while read line1; do echo $line1; done) & \
(./script2 | while read line2; do echo $line2; done)) | doSomethingWithOutput

È possibile creare una pipa denominata con mkfifo, scaricare tutto l'output nella pipa denominata e leggere separatamente dalla pipa denominata per i dati raccolti:

mkfifo /tmp/mypipe
job1 > /tmp/mypipe &
job2 > /tmp/mypipe &
job3 > /tmp/mypipe &

cat /tmp/mypipe > /path/to/final_output &

wait; wait; wait; wait