Как написать оболочку процесса-пула bash

Ответ 1

Я столкнулся с этой нитью, глядя на то, как писал свой собственный пул процессов и особенно понравился решение Brandon Horsley, хотя я не мог правильно работать с сигналами, поэтому я вдохнул вдохновение в Apache и решил попробовать модель pre-fork с fifo в качестве моей очереди заданий.

Следующая функция - это функция, выполняемая рабочими процессами при раздвоении.

# \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>&-
}

Вы можете получить копию моего решения в Github. Вот пример программы, использующей мою реализацию.

#!/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}"

Надеюсь, это поможет!

Ответ 2

Используйте xargs:

xargs -P <maximun-number-of-process-at-a-time> -n <arguments per process> <commnad>

Подробнее здесь.

Ответ 3

Используя GNU Parallel, вы можете:

cat tasks | parallel -j4 myprog

Если у вас есть 4 ядра, вы можете просто сделать:

cat tasks | parallel myprog

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

Полная установка

Полная установка GNU Parallel проста:

./configure && make && make install

Личная установка

Если вы не являетесь пользователем root, вы можете добавить ~/bin к своему пути и установить его ~/bin и ~/share:

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

Или, если вашей системе не хватает "make", вы можете просто скопировать src/parallel src/sem src/niceload src/sql в каталог на вашем пути.

Минимальная установка

Если вам просто нужна параллель и у вас нет "make" (возможно, система устарела или 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/

Проверьте установку

После этого вы сможете сделать:

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

Это будет отправлять три пакета ping на 3 разных хоста параллельно и распечатывать вывод при завершении.

Смотрите видеоролик для быстрого введения: https://www.youtube.com/playlist?list=PL284C9FF2488BC6D1

Ответ 4

Я бы предложил написать четыре сценария, каждый из которых выполняет определенное количество задач последовательно. Затем напишите еще один script, который запускает четыре сценария параллельно. Например, если у вас есть сценарии, script1.sh, script2.sh, script3.sh и script4.sh, вы можете иметь script, называемый headscript.sh, как это.

#!/bin/sh
./script1.sh & 
./script2.sh & 
./script3.sh & 
./script4.sh &

Ответ 5

Возможно, вы могли бы сделать что-то умное с сигналами.

Обратите внимание, что это только для иллюстрации концепции и, таким образом, не проверено полностью.

#!/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
  (
    "[email protected]"
    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

Ответ 6

Этот протестированный script запускает по 5 заданий одновременно и перезапустит новое задание, как только это произойдет (из-за убийства сна 10.9, когда мы получаем SIGCHLD. Простая версия этого может использовать прямой опрос ( измените сон 10.9, чтобы спать 1 и избавиться от ловушки).

#!/usr/bin/bash

set -o monitor
trap "pkill -P $$ -f 'sleep 10\.9' >&/dev/null" SIGCHLD

totaljobs=15
numjobs=5
worktime=10
curjobs=0
declare -A pidlist

dojob()
{
  slot=$1
  time=$(echo "$RANDOM * 10 / 32768" | bc -l)
  echo Starting job $slot with args $time
  sleep $time &
  pidlist[$slot]=`jobs -p %%`
  curjobs=$(($curjobs + 1))
  totaljobs=$(($totaljobs - 1))
}

# start
while [ $curjobs -lt $numjobs -a $totaljobs -gt 0 ]
 do
  dojob $curjobs
 done

# Poll for jobs to die, restarting while we have them
while [ $totaljobs -gt 0 ]
 do
  for ((i=0;$i < $curjobs;i++))
   do
    if ! kill -0 ${pidlist[$i]} >&/dev/null
     then
      dojob $i
      break
     fi
   done
   sleep 10.9 >&/dev/null
 done
wait

Ответ 7

После ответа @Parag Sardas и приведенной здесь документации приведен быстрый скрипт, который вы можете добавить к своему .bash_aliases.

Пересмотр ссылки на документ, потому что это стоит прочитать

#!/bin/bash
# https://stackoverflow.com/a/19618159
# https://stackoverflow.com/a/51861820
#
# Example file contents:
# touch /tmp/a.txt
# touch /tmp/b.txt

if [ "$#" -eq 0 ];  then
  echo "$0 <file> [max-procs=0]"
  exit 1
fi

FILE=${1}
MAX_PROCS=${2:-0}
cat $FILE | while read line; do printf "%q\n" "$line"; done | xargs --max-procs=$MAX_PROCS -I CMD bash -c CMD

Т.е.. /./xargs-parallel.sh jobs.txt 4 максимума из 4 процессов, прочитанных из jobs.txt

Ответ 8

Другой ответ о 4 сценариях оболочки не полностью удовлетворяет меня, поскольку он предполагает, что все задачи принимают приблизительно одинаковое время и потому что для этого требуется ручная настройка. Но вот как я его улучшу.

Основной script создаст символические ссылки на исполняемые файлы, следуя определенному соглашению namimg. Например,

ln -s executable1 ./01-task.01

первый префикс предназначен для сортировки, а суффикс идентифицирует пакет (01-04). Теперь мы создаем 4 сценария оболочки, которые будут принимать номер партии в качестве входных данных и делать что-то вроде этого

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

Ответ 9

Посмотрите на мою реализацию пула вакансий в bash: https://github.com/spektom/shell-utils/blob/master/jp.sh

Например, для запуска не более 3 процессов cURL при загрузке из большого количества URL-адресов вы можете обернуть свои команды cURL следующим образом:

./jp.sh "My Download Pool" 3 curl http://site1/...
./jp.sh "My Download Pool" 3 curl http://site2/...
./jp.sh "My Download Pool" 3 curl http://site3/...
...

Ответ 10

Вот мое решение. Идея довольно проста. Я создаю fifo как семафор, где каждая строка обозначает доступный ресурс. При read очереди основной процесс блокируется, если ничего не осталось. И мы возвращаемся ресурс после выполнения задачи осуществляется просто echo Инг ничего очереди.

function task() {
    local task_no="$1"
    # doing the actual task...
    echo "Executing Task ${task_no}"
    # which takes a long time
    sleep 1
}

function execute_concurrently() {
    local tasks="$1"
    local ps_pool_size="$2"

    # create an anonymous fifo as a Semaphore
    local sema_fifo
    sema_fifo="$(mktemp -u)"
    mkfifo "${sema_fifo}"
    exec 3<>"${sema_fifo}"
    rm -f "${sema_fifo}"

    # every 'x' stands for an available resource
    for i in $(seq 1 "${ps_pool_size}"); do
        echo 'x' >&3
    done

    for task_no in $(seq 1 "${tasks}"); do
        read dummy <&3 # blocks util a resource is available
        (
            trap 'echo x >&3' EXIT # returns the resource on exit
            task "${task_no}"
        )&
    done
    wait # wait util all forked tasks have finished
}

execute_concurrently 10 4

Приведенный выше скрипт будет запускать 10 задач и 4 каждый раз одновременно. Вы можете изменить последовательность $(seq 1 "${tasks}") на текущую очередь задач, которую вы хотите запустить.

Ответ 11

Я сделал свои модификации, основанные на методах, представленных в этом разделе Создание пула процессов в Bash.

#!/bin/bash

#set -e   # this doesn't work here for some reason
POOL_SIZE=4   # number of workers running in parallel

#######################################################################
#                            populate jobs                            #
#######################################################################

declare -a jobs

for (( i = 1988; i < 2019; i++ )); do
    jobs+=($i)
done

echo '################################################'
echo '    Launching jobs'
echo '################################################'

parallel() {
    local proc procs jobs cur
    jobs=("[email protected]")         # input jobs array
    declare -a procs=() # processes array
    cur=0               # current job idx

    morework=true
    while $morework; do
        # if process array size < pool size, try forking a new proc
        if [[ "${#procs[@]}" -lt "$POOL_SIZE" ]]; then
            if [[ $cur -lt "${#jobs[@]}" ]]; then
                proc=${jobs[$cur]}
                echo "JOB ID = $cur; JOB = $proc."

                ###############
                # do job here #
                ###############

                sleep 3 &

                # add to current running processes
                procs+=("$!")
                # move to the next job
                ((cur++))
            else
                morework=false
                continue
            fi
        fi

        for n in "${!procs[@]}"; do
            kill -0 "${procs[n]}" 2>/dev/null && continue
            # if process is not running anymore, remove from array
            unset procs[n]
        done
    done
    wait
}

parallel "${jobs[@]}"