У меня есть более 10 задач для выполнения, и система ограничивает возможность выполнения не более 4 задач одновременно.
Моя задача может быть запущена как: myprog taskname
Как я могу написать оболочку bash script для запуска этой задачи. Самое главное, что когда одна задача заканчивается, script может сразу запустить другую, делая подсчет запущенных задач все время 4.
Я столкнулся с этой нитью, глядя на то, как писал свой собственный пул процессов и особенно понравился решение 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}"
Надеюсь, это поможет!
Используйте xargs:
xargs -P <maximun-number-of-process-at-a-time> -n <arguments per process> <commnad>
Подробнее здесь.
Используя 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
Я бы предложил написать четыре сценария, каждый из которых выполняет определенное количество задач последовательно. Затем напишите еще один script, который запускает четыре сценария параллельно. Например, если у вас есть сценарии, script1.sh, script2.sh, script3.sh и script4.sh, вы можете иметь script, называемый headscript.sh, как это.
#!/bin/sh
./script1.sh &
./script2.sh &
./script3.sh &
./script4.sh &
Возможно, вы могли бы сделать что-то умное с сигналами.
Обратите внимание, что это только для иллюстрации концепции и, таким образом, не проверено полностью.
#!/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
Этот протестированный 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
После ответа @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
Другой ответ о 4 сценариях оболочки не полностью удовлетворяет меня, поскольку он предполагает, что все задачи принимают приблизительно одинаковое время и потому что для этого требуется ручная настройка. Но вот как я его улучшу.
Основной script создаст символические ссылки на исполняемые файлы, следуя определенному соглашению namimg. Например,
ln -s executable1 ./01-task.01
первый префикс предназначен для сортировки, а суффикс идентифицирует пакет (01-04). Теперь мы создаем 4 сценария оболочки, которые будут принимать номер партии в качестве входных данных и делать что-то вроде этого
for t in $(ls ./*-task.$batch | sort ; do
t
rm t
done
Посмотрите на мою реализацию пула вакансий в 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/...
...
Вот мое решение. Идея довольно проста. Я создаю 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}") на текущую очередь задач, которую вы хотите запустить.
Я сделал свои модификации, основанные на методах, представленных в этом разделе Создание пула процессов в 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[@]}"