有没有一种简单的方法来限制在bash并发作业的数量？ 我的意思是制作和块时有更多的则n在后台运行并行作业。
我知道我可以用ps实现这个| 用grep式的招数，但有一个更简单的方法？
Answer 1:
如果你已经GNU并行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并行不打包分发，你可以安装GNU通过简单的类比：
(wget -O - pi.dk/3 || curl pi.dk/3/ || fetch -o - http://pi.dk/3) | bash
它会下载，检查签名，并做了个人安装，如果它不能在全球安装。
留意GNU的介绍视频平行了解更多： https://www.youtube.com/playlist?list=PL284C9FF2488BC6D1
Answer 2:
一个小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中是丑陋的，但我没有找到一个方法来等待终止第一份工作。
Answer 3:
下面的脚本显示了一种方法与功能做到这一点。 您可以把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 [ ]
- 整个事情开始于十二时38分00秒，正如你可以看到，前三过程立即运行。
- 每个进程休眠
n*10秒钟，这样第四过程不会开始，直到第一出口（在时间t = 10或12点38分10秒）。 你可以看到进程已经3368从名单中消失加入1560之前。 - 类似地，当第二（5880）离开在时间t = 20的第五工序（5032）开始。
- 最后，当第三（2524）离开在时间t = 30的第六处理（5212）开始。
- 然后破旧开始，第四过程退出在t = 50（在10开始，40持续时间），第五在t = 70（在20开始，50持续时间）和第六在t = 90（在30开始，60持续时间）。
或者，在时间线的形式：
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
Answer 4:
这里的最短途径：
waitforjobs() {
while test $(jobs -p | wc -w) -ge "$1"; do wait -n; done
}
呼叫分叉关闭任何新的工作之前，这样的功能：
waitforjobs 10
run_another_job &
有尽可能多的后台作业的机器上的核心，使用$(nproc)而不是一个固定的数字，如10。
Answer 5:
假设你想写这样的代码：
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
}
Answer 6:
这可能是对大多数来说已经足够好，但不是最优的。
#!/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
Answer 7:
如果你愿意这样做纯粹的庆典之外，你应该考虑的作业排队系统。
例如，有GNU队列或者PBS 。 而对于PBS，你可能想寻找到毛伊岛的配置。
这两种系统都需要进行一些配置，但它是完全有可能允许工作的具体数量同时运行，仅在启动新排队的作业时，正在运行的作业完成。 通常情况下，这些作业排队系统将在超级计算集群，在那里你会想分配的内存或计算时间，任何给定的批处理作业特定的量使用; 然而，没有理由不能使用的这些一台台式计算机上的一个不用于计算时间或内存限制方面。
Answer 8:
在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
Answer 9:
下面的函数（从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）等待在现有的后台任务，而不是投票结束后，快速任务提高效率
Answer 10:
你有没有考虑起十长时间运行的侦听器进程，并通过命名管道与他们沟通？
Answer 11:
你可以使用的ulimit -u看到http://ss64.com/bash/ulimit.html
文章来源: Bash: limit the number of concurrent jobs?
