是否有一种简单的方法来限制bash中的并发作业数量？我的意思是制作＆amp;在后台运行多于n个并发作业时阻止。
我知道我可以用ps实现这个grep-style技巧，但有更简单的方法吗？
答案 0 :(得分：19)
一个小的bash脚本可以帮助你：
# content of script exec-async.sh
joblist=($(jobs -p))
while (( ${#joblist[*]} >= 3 ))
do
sleep 1
joblist=($(jobs -p))
done
$* &
如果你打电话：
. exec-async.sh sleep 10
...四次，前三次调用将立即返回，第四次调用将阻塞，直到运行的作业少于三个。
您需要在当前会话中启动此脚本，方法是在其前面添加.，因为jobs仅列出当前会话的作业。
里面的sleep很难看，但是我没有办法等待第一个终止的工作。
答案 1 :(得分：19)
以下脚本显示了使用函数执行此操作的方法。您可以将bgxupdate和bgxlimit函数放在脚本中，也可以将它们放在一个单独的文件中，该文件来自您的脚本：
. /path/to/bgx.sh
它的优点是您可以独立维护多组进程（例如，您可以运行一组限制为10的组和另一组完全独立的组，限制为3）。
它使用bash内置的jobs来获取子流程列表，但将它们保存在各个变量中。在底部的循环中，您可以看到如何调用bgxlimit函数：
bgxgrp。bgxlimit。当然，如果您只有一个群组，请直接使用bgxgrp，而不是转入和转出。
#!/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
这是一个示例运行：
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 [ ]
n*10秒，因此第四个进程在第一个进程退出之前（时间t = 10或12:38:10）才会启动。在添加1560之前，您可以看到进程3368已从列表中消失。或者，以时间线形式：
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
答案 2 :(得分：19)
如果你安装了GNU Parallel http://www.gnu.org/software/parallel/，你可以这样做：
parallel gzip ::: *.log
将为每个CPU核心运行一个gzip，直到所有日志文件都被gzip压缩。
如果它是较大循环的一部分，则可以使用sem代替：
for i in *.log ; do
echo $i Do more stuff here
sem -j+0 gzip $i ";" echo done
done
sem --wait
它会做同样的事情，但是让你有机会为每个文件做更多的事情。
如果没有为您的发行版打包GNU Parallel，您可以通过以下方式安装GNU Parallel：
(wget -O - pi.dk/3 || curl pi.dk/3/ || fetch -o - http://pi.dk/3) | bash
如果无法全局安装，它将下载，检查签名并进行个人安装。
观看GNU Parallel的介绍视频了解详情： https://www.youtube.com/playlist?list=PL284C9FF2488BC6D1
答案 3 :(得分：12)
这是最简短的方法：
waitforjobs() {
while test $(jobs -p | wc -w) -ge "$1"; do wait -n; done
}
在分离任何新工作之前调用此函数：
waitforjobs 10
run_another_job &
要在计算机上拥有与核心一样多的后台作业，请使用$(nproc)而不是像10这样的固定数字。
答案 4 :(得分：10)
假设你想写这样的代码：
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
max_bg_procs应放在.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
}
答案 5 :(得分：5)
这对于大多数用途来说可能已经足够了，但并不是最佳目的。
#!/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
答案 6 :(得分：3)
如果你愿意在纯粹的bash之外做这件事，你应该调查一个工作排队系统。
例如，有GNU queue或PBS。对于PBS，您可能需要查看Maui的配置。
两个系统都需要一些配置，但完全可以允许一次运行特定数量的作业，只在正在运行的作业完成时启动新排队的作业。通常，这些作业排队系统将用于超级计算集群，您可能希望为任何给定的批处理作业分配特定数量的内存或计算时间;但是，没有理由不在计算时间或内存限制的情况下在单台台式计算机上使用其中一台。
答案 7 :(得分：2)
以下功能（从上面的tangens开发，复制到脚本或文件来源）：
job_limit () {
# Test for single positive integer input
if (( $# == 1 )) && [[ $1 =~ ^[1-9][0-9]*$ ]]
then
# Check number of running jobs
joblist=($(jobs -rp))
while (( ${#joblist[*]} >= $1 ))
do
# Wait for any job to finish
command='wait '${joblist[0]}
for job in ${joblist[@]:1}
do
command+=' || wait '$job
done
eval $command
joblist=($(jobs -rp))
done
fi
}
1）仅需要插入一行来限制现有循环
while :
do
task &
job_limit `nproc`
done
2）等待完成现有后台任务而不是轮询，提高快速任务的效率
答案 8 :(得分：1)
在Linux上我使用它来将bash作业限制为可用CPU的数量（可能通过设置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
答案 9 :(得分：1)
不等待-n很难完成（例如，busybox中的shell不支持它）。因此，这是一种解决方法，不是最佳选择，因为它每秒以10x的速度调用“ jobs”和“ wc”命令。例如，如果您不介意为每个作业等待更长的时间，可以将通话次数降低到每秒1次。
# $1 = maximum concurent jobs
#
limit_jobs()
{
while true; do
if [ "$(jobs -p | wc -l)" -lt "$1" ]; then break; fi
usleep 100000
done
}
# and now start some tasks:
task &
limit_jobs 2
task &
limit_jobs 2
task &
limit_jobs 2
task &
limit_jobs 2
wait
答案 10 :(得分：0)
您是否考虑过启动十个长时间运行的侦听器进程并通过命名管道与它们进行通信？
答案 11 :(得分：0)
你可以使用ulimit -u 见http://ss64.com/bash/ulimit.html
答案 12 :(得分：0)
Bash主要逐行处理文件。 因此，您将分割的输入文件输入文件用N行加盖，然后可以使用简单的模式：
mkdir tmp ; pushd tmp ; split -l 50 ../mainfile.txt
for file in * ; do
while read a b c ; do curl -s http://$a/$b/$c <$file &
done ; wait ; done
popd ; rm -rf tmp;
答案 13 :(得分：0)
Wait 命令，-n 选项，等待下一个作业终止。
maxjobs=10
# wait for the amount of processes less to $maxjobs
jobIds=($(jobs -p))
len=${#jobIds[@]}
while [ $len -ge $maxjobs ]; do
# Wait until one job is finished
wait -n $jobIds
jobIds=($(jobs -p))
len=${#jobIds[@]}
done