Bash: Begrenzen Sie die Anzahl gleichzeitiger Jobs?

Das folgende Skript zeigt eine Möglichkeit, dies mit Funktionen. Sie können entweder die bgxupdate und bgxlimit Funktionen in Ihrem Skript oder in einer separaten Datei, die stammt aus dem Skript mit:

. /path/to/bgx.sh

Es hat den Vorteil, dass Sie pflegen können mehrere Gruppen von Prozessen voneinander unabhängig (Sie können laufen, zum Beispiel, eine Gruppe mit einem limit von 10 und andere separate Gruppe mit einem limit von 3).

Es verwendet die bash built-in jobs, um eine Liste der sub-Prozesse, sondern pflegt diese in den einzelnen Variablen. In der Schleife an der Unterseite, können Sie sehen, wie nennen die bgxlimit Funktion:

• einrichten einer leeren Gruppe variable.
• übertragen Sie das auf bgxgrp.
• nennen bgxlimit mit dem limit Befehl, den Sie ausführen möchten.
• transfer der neuen Gruppe zurück zu Ihrer Gruppe variable.

Natürlich, wenn man nur eine Gruppe, verwenden Sie einfach bgxgrp direkt anstatt die übertragung in die und aus.

#!/bin/bash

# bgxupdate - update active processes in a group.
#   Works by transferring each process to new group
#   if it is still active.
# in:  bgxgrp - current group of processes.
# out: bgxgrp - new group of processes.
# out: bgxcount - number of processes in new group.

bgxupdate() {
    bgxoldgrp=${bgxgrp}
    bgxgrp=""
    ((bgxcount = 0))
    bgxjobs=" $(jobs -pr | tr '\n' ' ')"
    for bgxpid in ${bgxoldgrp} ; do
        echo "${bgxjobs}" | grep " ${bgxpid} " >/dev/null 2>&1
        if [[ $? -eq 0 ]] ; then
            bgxgrp="${bgxgrp} ${bgxpid}"
            ((bgxcount = bgxcount + 1))
        fi
    done
}

# bgxlimit - start a sub-process with a limit.

#   Loops, calling bgxupdate until there is a free
#   slot to run another sub-process. Then runs it
#   an updates the process group.
# in:  $1     - the limit on processes.
# in:  $2+    - the command to run for new process.
# in:  bgxgrp - the current group of processes.
# out: bgxgrp - new group of processes

bgxlimit() {
    bgxmax=$1 ; shift
    bgxupdate
    while [[ ${bgxcount} -ge ${bgxmax} ]] ; do
        sleep 1
        bgxupdate
    done
    if [[ "$1" != "-" ]] ; then
        $* &
        bgxgrp="${bgxgrp} $!"
    fi
}

# Test program, create group and run 6 sleeps with
#   limit of 3.

group1=""
echo 0 $(date | awk '{print $4}') '[' ${group1} ']'
echo
for i in 1 2 3 4 5 6 ; do
    bgxgrp=${group1} ; bgxlimit 3 sleep ${i}0 ; group1=${bgxgrp}
    echo ${i} $(date | awk '{print $4}') '[' ${group1} ']'
done

# Wait until all others are finished.

echo
bgxgrp=${group1} ; bgxupdate ; group1=${bgxgrp}
while [[ ${bgxcount} -ne 0 ]] ; do
    oldcount=${bgxcount}
    while [[ ${oldcount} -eq ${bgxcount} ]] ; do
        sleep 1
        bgxgrp=${group1} ; bgxupdate ; group1=${bgxgrp}
    done
    echo 9 $(date | awk '{print $4}') '[' ${group1} ']'
done

Hier ist ein Beispiel-Lauf:

0 12:38:00 [ ]

1 12:38:00 [ 3368 ]
2 12:38:00 [ 3368 5880 ]
3 12:38:00 [ 3368 5880 2524 ]
4 12:38:10 [ 5880 2524 1560 ]
5 12:38:20 [ 2524 1560 5032 ]
6 12:38:30 [ 1560 5032 5212 ]

9 12:38:50 [ 5032 5212 ]
9 12:39:10 [ 5212 ]
9 12:39:30 [ ]

• Das ganze beginnt um 12:38:00 und, wie Sie sehen können, die ersten drei Prozesse, die sofort ausgeführt werden.
• Jeder Prozess schläft n*10 Sekunden, so dass der vierte Prozess wird nicht gestartet, bis die ersten Ausfahrten (zur Zeit t=10 oder 12:38:10). Sie können sehen, dass Prozess 3368 hat aus der Liste verschwunden, bevor 1560 Hinzugefügt.
• Ähnlich, der fünfte Prozess (5032) startet, wenn der zweite (5880) beendet zur Zeit t=20.
• Und schließlich der sechste Prozess (5212) startet, wenn der Dritte (2524) beendet zur Zeit t=30.
• Dann den rundown beginnt, vierten Prozess beendet sich bei t=50 (gestartet bei 10 Uhr, Dauer 40), fünfte bei t=70 (angefangen bei 20, Dauer 50) und der sechsten bei t=90 (angefangen bei 30, Dauer 60).

Oder, in der Zeit-Online-Formular:

Process:  1  2  3  4  5  6 
--------  -  -  -  -  -  -
12:38:00  ^  ^  ^
12:38:10  v  |  |  ^
12:38:20     v  |  |  ^
12:38:30        v  |  |  ^
12:38:40           |  |  |
12:38:50           v  |  |
12:39:00              |  | 
12:39:10              v  |
12:39:20                 |
12:39:30                 v

InformationsquelleAutor der Antwort paxdiablo

Vorausgesetzt, Sie möchten, schreiben Sie code wie diesen:

for x in $(seq 1 100); do     # 100 things we want to put into the background.
    max_bg_procs 5            # Define the limit. See below.
    your_intensive_job &
done

Wo max_bg_procs sein sollte, setzen Sie in Ihrem .bashrc:

function max_bg_procs {
    if [[ $# -eq 0 ]] ; then
            echo "Usage: max_bg_procs NUM_PROCS.  Will wait until the number of background (&)"
            echo "           bash processes (as determined by 'jobs -pr') falls below NUM_PROCS"
            return
    fi
    local max_number=$((0 + ${1:-0}))
    while true; do
            local current_number=$(jobs -pr | wc -l)
            if [[ $current_number -lt $max_number ]]; then
                    break
            fi
            sleep 1
    done
}

InformationsquelleAutor der Antwort Aaron McDaid

Diesem vielleicht gut genug für die meisten Zwecke aber nicht optimal.

#!/bin/bash

n=0
maxjobs=10

for i in *.m4a ; do
    # ( DO SOMETHING ) &

    # limit jobs
    if (( $(($((++n)) % $maxjobs)) == 0 )) ; then
        wait # wait until all have finished (not optimal, but most times good enough)
        echo $n wait
    fi
done

InformationsquelleAutor der Antwort cat

Unter Linux verwende ich diese zur Begrenzung der bash Arbeitsplätze zu der Anzahl der verfügbaren CPUs (möglicherweise überschrieben durch die Einstellung der CPU_NUMBER).

[ "$CPU_NUMBER" ] || CPU_NUMBER="`nproc 2>/dev/null || echo 1`"

while [ "$1" ]; do
    {
        do something
        with $1
        in parallel

        echo "[$# items left] $1 done"
    } &

    while true; do
        # load the PIDs of all child processes to the array
        joblist=(`jobs -p`)
        if [ ${#joblist[*]} -ge "$CPU_NUMBER" ]; then
            # when the job limit is reached, wait for *single* job to finish
            wait -n
        else
            # stop checking when we're below the limit
            break
        fi
    done
    # it's great we executed zero external commands to check!

    shift
done

# wait for all currently active child processes
wait

InformationsquelleAutor der Antwort Tuttle

können Sie ulimit -u
sehen http://ss64.com/bash/ulimit.html

InformationsquelleAutor der Antwort Shay