Eine begrenzte Anzahl von Kind-Prozessen parallel in bash ausführen?

Habe ich eine große Menge von Dateien, für die einige schwere Verarbeitung getan werden muss.
Diese Verarbeitung in einem einzelnen Thread, nutzt ein paar hundert MiB RAM (auf der Maschine verwendet, um den Auftrag zu starten) und dauert ein paar Minuten zu laufen.
Mein Aktueller Anwendungsfall ist zum start eines hadoop-Jobs auf die input-Daten, aber ich hatte das gleiche problem in anderen Fällen vor.

Um die volle Nutzung der verfügbaren CPU-Leistung will ich in der Lage laufen mehrere diese Aufgaben paralell.

Jedoch eine sehr einfache Beispiel-shell-Skript wie das Müll system-performance durch übermäßiges laden und austauschen:

find . -type f | while read name ; 
do 
   some_heavy_processing_command ${name} &
done

Also, was ich will, ist im wesentlichen ähnlich zu dem, was "gmake -j4" nicht.

Ich weiß die bash unterstützt die "warten" - Befehl, aber das nur wartet bis alle Kind-Prozesse beendet sind. In der Vergangenheit habe ich erstellt, ein Skript muss ein 'ps' Befehl und dann die grep-die Kind-Prozesse nach Namen (ja, ich weiß ... hässlich).

Was ist der einfachste/sauberste/beste Lösung, um zu tun, was ich will?

Edit: Danke an Frederik: ja, in der Tat ist dies ein Duplikat von Wie begrenzen Sie die Anzahl der threads/sub-Prozesse in einer Funktion in bash
Das "xargs --max-procs=4" funktioniert wie ein Charme.
(Also ich habe auf meine eigene Frage)

InformationsquelleAutor der Frage Niels Basjes | 2011-07-06

  1. 18
    #! /usr/bin/env bash

set -o monitor 
# means: run background processes in a separate processes...
trap add_next_job CHLD 
# execute add_next_job when we receive a child complete signal

todo_array=($(find . -type f)) # places output into an array

index=0
max_jobs=2

function add_next_job {
    # if still jobs to do then add one
    if [[ $index -lt ${#todo_array[*]} ]]
    # apparently stackoverflow doesn't like bash syntax
    # the hash in the if is not a comment - rather it's bash awkward way of getting its length
    then
        echo adding job ${todo_array[$index]}
        do_job ${todo_array[$index]} & 
        # replace the line above with the command you want
        index=$(($index+1))
    fi
}

function do_job {
    echo "starting job $1"
    sleep 2
}

# add initial set of jobs
while [[ $index -lt $max_jobs ]]
do
    add_next_job
done

# wait for all jobs to complete
wait
echo "done"

    Gesagt haben, dass Fredrik lässt den exzellenten Punkt, dass xargs macht genau das, was Sie wollen...

    InformationsquelleAutor der Antwort Dunes

  2. 20

    Ich weiß, ich bin spät zur party mit dieser Antwort, aber ich dachte, ich würde post eine alternative, die, IMHO, macht der Körper das Skript sauberer und einfacher. (Klar kann man die Werte ändern 2 & 5 werden für Ihr Szenario geeignet.)

    function max2 {
   while [ `jobs | wc -l` -ge 2 ]
   do
      sleep 5
   done
}

find . -type f | while read name ; 
do 
   max2; some_heavy_processing_command ${name} &
done
wait

    InformationsquelleAutor der Antwort BruceH

  3. 8

    Mit GNU Parallel wird es einfacher:

    find . -type f | parallel  some_heavy_processing_command {}

    Erfahren Sie mehr: https://www.youtube.com/playlist?list=PL284C9FF2488BC6D1

    InformationsquelleAutor der Antwort Ole Tange

  4. 4

    Ich glaube, ich fand die praktische Lösung mit :

    #!/usr/bin/make -f

THIS := $(lastword $(MAKEFILE_LIST))
TARGETS := $(shell find . -name '*.sh' -type f)

.PHONY: all $(TARGETS)

all: $(TARGETS)

$(TARGETS):
        some_heavy_processing_command $@

$(THIS): ; # Avoid to try to remake this makefile

    Nennen, wie z.B. 'test.mak', und fügen Sie die execute-Rechte. Wenn Sie anrufen ./test.mak es rufen die some_heavy_processing_command one-by-one. Aber Sie können rufen wie ./test.mak -j 4dann wird es laufen vier Teilprozesse auf einmal. Auch Sie können es auf eine elegantere Art: Ausführung als ./test.mak -j 5 -l 1.5dann wird es laufen maximal 5 sub-Prozesse und die Systemlast unter 1.5, aber es wird die Anzahl der Prozesse, wenn die Systemauslastung größer als 1,5.

    Es ist flexibler als xargs und ist Teil der standard-distribution, nicht wie parallel.

    InformationsquelleAutor der Antwort TrueY

  5. 3

    Dieser code funktionierte ziemlich gut für mich.

    Bemerkte ich ein Problem, bei dem das Skript konnte nicht zu Ende.
    Wenn Sie in einem Fall, in dem das Skript nicht beenden aufgrund max_jobs größer als die Anzahl der Elemente im array, wird das script nie beendet.

    Um zu verhindern, dass die oben genannten Szenario, ich habe die folgenden direkt nach der "max_jobs" Erklärung.

    if [ $max_jobs -gt ${#todo_array[*]} ];
    then
           # there are more elements found in the array than max jobs, setting max jobs to #of array elements"
            max_jobs=${#todo_array[*]}
 fi

    InformationsquelleAutor der Antwort masseo

  6. -1

    Andere Möglichkeit:

    PARALLEL_MAX=...
function start_job() {
  while [ $(ps --no-headers -o pid --ppid=$$ | wc -l) -gt $PARALLEL_MAX ]; do
    sleep .1  # Wait for background tasks to complete.                         
  done
  "$@" &
}
start_job some_big_command1
start_job some_big_command2
start_job some_big_command3
start_job some_big_command4
...

    InformationsquelleAutor der Antwort Jeff Kaufman

  7. -1

    Hier ist eine sehr gute Funktion, die ich verwendet, um zu Steuern, die maximale Anzahl der jobs von der bash oder ksh. ANMERKUNG: die - 1 in der pgrep subtrahiert die wc -l Teilprozess.

    function jobmax
{
    typeset -i MAXJOBS=$1
    sleep .1
    while (( ($(pgrep -P $$ | wc -l) - 1) >= $MAXJOBS ))
    do
        sleep .1
    done
}

nproc=5
for i in {1..100}
do
    sleep 1 &
    jobmax $nproc
done
wait # Wait for the rest

    InformationsquelleAutor der Antwort user2709129

Schreibe einen Kommentar