wie man eine Prozess-Pool-Bash-Shell schreibt

Ich zufällig auf diesen thread beim Blick auf das schreiben meiner eigenen pool und besonders mochte Brandon Horsley ' s Lösung, aber ich konnte nicht die Signale richtig funktionieren, so dass ich nahm inspiration von Apache und beschlossen, zu versuchen, eine pre-fork-Modell mit einem fifo als mein job-Warteschlange.

Die folgende Funktion ist die Funktion, dass die worker Prozesse führen, wenn die Gabel.

# \brief the worker function that is called when we fork off worker processes
# \param[in] id  the worker ID
# \param[in] job_queue  the fifo to read jobs from
# \param[in] result_log  the temporary log file to write exit codes to
function _job_pool_worker()
{
    local id=$1
    local job_queue=$2
    local result_log=$3
    local line=

    exec 7<> ${job_queue}
    while [[ "${line}" != "${job_pool_end_of_jobs}" && -e "${job_queue}" ]]; do
        # workers block on the exclusive lock to read the job queue
        flock --exclusive 7
        read line <${job_queue}
        flock --unlock 7
        # the worker should exit if it sees the end-of-job marker or run the
        # job otherwise and save its exit code to the result log.
        if [[ "${line}" == "${job_pool_end_of_jobs}" ]]; then
            # write it one more time for the next sibling so that everyone
            # will know we are exiting.
            echo "${line}" >&7
        else
            _job_pool_echo "### _job_pool_worker-${id}: ${line}"
            # run the job
            { ${line} ; } 
            # now check the exit code and prepend "ERROR" to the result log entry
            # which we will use to count errors and then strip out later.
            local result=$?
            local status=
            if [[ "${result}" != "0" ]]; then
                status=ERROR
            fi  
            # now write the error to the log, making sure multiple processes
            # don't trample over each other.
            exec 8<> ${result_log}
            flock --exclusive 8
            echo "${status}job_pool: exited ${result}: ${line}" >> ${result_log}
            flock --unlock 8
            exec 8>&-
            _job_pool_echo "### _job_pool_worker-${id}: exited ${result}: ${line}"
        fi  
    done
    exec 7>&-
}

Können Sie Holen Sie sich eine Kopie von meiner Lösung auf Github. Hier ist ein Beispiel-Programm mit meiner Umsetzung.

#!/bin/bash

. job_pool.sh

function foobar()
{
    # do something
    true
}   

# initialize the job pool to allow 3 parallel jobs and echo commands
job_pool_init 3 0

# run jobs
job_pool_run sleep 1
job_pool_run sleep 2
job_pool_run sleep 3
job_pool_run foobar
job_pool_run foobar
job_pool_run /bin/false

# wait until all jobs complete before continuing
job_pool_wait

# more jobs
job_pool_run /bin/false
job_pool_run sleep 1
job_pool_run sleep 2
job_pool_run foobar

# don't forget to shut down the job pool
job_pool_shutdown

# check the $job_pool_nerrors for the number of jobs that exited non-zero
echo "job_pool_nerrors: ${job_pool_nerrors}"

Hoffe, das hilft!

InformationsquelleAutor der Antwort thelazyenginerd

Mit GNU Parallel, die Sie tun können:

cat tasks | parallel -j4 myprog

Wenn du 4 Kerne, kannst du auch einfach tun:

cat tasks | parallel myprog

Vom http://git.savannah.gnu.org/cgit/parallel.git/tree/README:

Vollständige installation

Vollständige installation von GNU Parallel ist so einfach wie:

./configure && make && make install

Persönliche installation

Wenn Sie nicht root sind, können Sie fügen Sie ~/bin zu Ihrem Pfad und installieren Sie Sie
~/bin und ~/share:

./configure --prefix=$HOME && make && make install

Oder wenn Ihr system fehlt 'machen' Sie können einfach kopieren Sie src/parallel
src/sem src/niceload src/sql die dir im Weg liegen.

Minimal-installation

Wenn Sie nur parallel und nicht 'make' installiert (vielleicht die
system ist alt oder Microsoft Windows):

wget http://git.savannah.gnu.org/cgit/parallel.git/plain/src/parallel
chmod 755 parallel
cp parallel sem
mv parallel sem dir-in-your-$PATH/bin/

Test der installation

Danach sollten Sie in der Lage sein zu tun:

parallel -j0 ping -nc 3 ::: foss.org.my gnu.org freenetproject.org

Dieser schicken 3 ping-Pakete an 3 verschiedenen Rechnern parallel und print
die Ausgabe, wenn Sie vollständig sind.

Sehen Sie das intro-video für eine schnelle Einführung:
https://www.youtube.com/playlist?list=PL284C9FF2488BC6D1

InformationsquelleAutor der Antwort Ole Tange

Könnte Sie wahrscheinlich etwas clever mit Signale.

Hinweis: dies ist nur um zu veranschaulichen, das Konzept, und somit nicht ausgiebig getestet.

#!/usr/local/bin/bash

this_pid="$$"
jobs_running=0
sleep_pid=

# Catch alarm signals to adjust the number of running jobs
trap 'decrement_jobs' SIGALRM

# When a job finishes, decrement the total and kill the sleep process
decrement_jobs()
{
  jobs_running=$(($jobs_running - 1))
  if [ -n "${sleep_pid}" ]
  then
    kill -s SIGKILL "${sleep_pid}"
    sleep_pid=
  fi
}

# Check to see if the max jobs are running, if so sleep until woken
launch_task()
{
  if [ ${jobs_running} -gt 3 ]
  then
    (
      while true
      do
        sleep 999
      done
    ) &
    sleep_pid=$!
    wait ${sleep_pid}
  fi

  # Launch the requested task, signalling the parent upon completion
  (
    "$@"
    kill -s SIGALRM "${this_pid}"
  ) &
  jobs_running=$((${jobs_running} + 1))
}

# Launch all of the tasks, this can be in a loop, etc.
launch_task task1
launch_task tast2
...
launch_task task99

InformationsquelleAutor der Antwort Brandon Horsley

Andere Antwort über 4 shell-Skripte nicht vollständig befriedigt mich, wie es wird davon ausgegangen, dass alle Aufgaben approximatelu der gleichen Zeit, und da es erfordert die manuelle Einrichtung. Aber hier ist, wie ich es noch verbessern.

Haupt-Skript erstellen, werden symbolische links auf ausführbare Dateien nach bestimmten namimg Konvention. Zum Beispiel,

ln -s executable1 ./01-task.01

erste Präfix ist für die Sortierung und-suffix identifiziert die batch - (01-04).
Jetzt haben wir spawn-4-shell-scripts, batch-Nummer, wie Sie Eingangs-und tun so etwas wie dieses

for t in $(ls ./*-task.$batch | sort ; do
   t
   rm t
done

InformationsquelleAutor der Antwort Alex Gitelman