sta*_*tti 31 bash shell concurrency
是否有一种简单的方法来限制bash中的并发作业数量？我的意思是当在后台运行多于n个并发作业时进行&阻止.
我知道我可以用ps实现这个 grep-style技巧,但有更简单的方法吗？
Ole*_*nge 23
如果你安装了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 || lynx -source pi.dk/3 || curl pi.dk/3/ || \
fetch -o - http://pi.dk/3 ) > install.sh
$ sha1sum install.sh | grep 3374ec53bacb199b245af2dda86df6c9
12345678 3374ec53 bacb199b 245af2dd a86df6c9
$ md5sum install.sh | grep 029a9ac06e8b5bc6052eac57b2c3c9ca
029a9ac0 6e8b5bc6 052eac57 b2c3c9ca
$ sha512sum install.sh | grep f517006d9897747bed8a4694b1acba1b
40f53af6 9e20dae5 713ba06c f517006d 9897747b ed8a4694 b1acba1b 1464beb4
60055629 3f2356f3 3e9c4e3c 76e3f3af a9db4b32 bd33322b 975696fc e6b23cfb
$ bash install.sh
如果无法全局安装,它将下载,检查签名并进行个人安装.
观看GNU Parallel的介绍视频以了解更多信息:https: //www.youtube.com/playlist？list = PL284C9FF2488BC6D1
tan*_*ens 21
一个小的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里面是丑陋的,但我没有找到一个方法来等待终止第一份工作.
pax*_*blo 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
Sca*_*tle 16
这是最短的方式:
waitforjobs() {
while test $(jobs -p | wc -w) -ge "$1"; do wait -n; done
}
在分离任何新工作之前调用此函数:
waitforjobs 10
run_another_job &
要在计算机上拥有与核心一样多的后台作业,请使用$(nproc)而不是像10这样的固定数字.
Aar*_*aid 11
假设你想写这样的代码:
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
}
对于大多数目的而言,这可能足够好,但不是最佳的.
#!/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
以下功能（从上面的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）等待现有的后台任务完成而不是轮询，从而提高快速任务的效率