使用最大进程数并行化Bash脚本

时间：2008-09-01 16:47:53

标签： bash

假设我在Bash中有一个循环：

for foo in `some-command`
do
   do-something $foo
done

do-something是cpu绑定的，我有一个漂亮闪亮的4核心处理器。我希望能够一次最多运行4 do-something。

天真的做法似乎是：

for foo in `some-command`
do
   do-something $foo &
done

这将立即运行所有 do-something，但有一些缺点，主要是这样做 - 某些东西也可能有一些重要的I / O执行 all < / em>马上可能会慢一点。另一个问题是这个代码块立即返回，因此当所有do-something完成时，无法完成其他工作。

你如何编写这个循环，以便一次运行X do-something？

16 个答案:

答案 0 :(得分：54)

根据您的想法，xargs也可以提供帮助（此处：使用pdf2ps转换文档）：

cpus=$( ls -d /sys/devices/system/cpu/cpu[[:digit:]]* | wc -w )

find . -name \*.pdf | xargs --max-args=1 --max-procs=$cpus  pdf2ps

来自文档：

--max-procs=max-procs
-P max-procs
       Run up to max-procs processes at a time; the default is 1.
       If max-procs is 0, xargs will run as many processes as  possible  at  a
       time.  Use the -n option with -P; otherwise chances are that only one
       exec will be done.

答案 1 :(得分：35)

使用GNU Parallel http://www.gnu.org/software/parallel/，您可以写：

some-command | parallel do-something

GNU Parallel还支持在远程计算机上运行作业。这将在远程计算机上为每个CPU核心运行一个 - 即使它们具有不同数量的核心：

some-command | parallel -S server1,server2 do-something

更高级的示例：这里我们列出了我们希望运行my_script的文件。文件有扩展名（可能是.jpeg）。我们希望my_script的输出放在basename.out中的文件旁边（例如foo.jpeg - ＆gt; foo.out）。我们想为计算机的每个核心运行一次my_script，我们也希望在本地计算机上运行它。对于远程计算机，我们希望将文件处理传输到给定的计算机。当my_script完成时，我们希望将foo.out转回，然后我们要从远程计算机中删除foo.jpeg和foo.out：

cat list_of_files | \
parallel --trc {.}.out -S server1,server2,: \
"my_script {} > {.}.out"

GNU Parallel确保每个作业的输出不会混合，因此您可以将输出用作另一个程序的输入：

some-command | parallel do-something | postprocess

有关更多示例，请参阅视频：https://www.youtube.com/playlist?list=PL284C9FF2488BC6D1

答案 2 :(得分：23)

maxjobs=4
parallelize () {
        while [ $# -gt 0 ] ; do
                jobcnt=(`jobs -p`)
                if [ ${#jobcnt[@]} -lt $maxjobs ] ; then
                        do-something $1 &
                        shift  
                else
                        sleep 1
                fi
        done
        wait
}

parallelize arg1 arg2 "5 args to third job" arg4 ...

答案 3 :(得分：11)

使用Makefile，而不是普通bash，然后使用make -jX指定同时作业的数量，其中X是一次运行的作业数。

或者您可以使用wait（“man wait”）：启动多个子进程，调用wait - 当子进程完成时它将退出。

maxjobs = 10

foreach line in `cat file.txt` {
 jobsrunning = 0
 while jobsrunning < maxjobs {
  do job &
  jobsrunning += 1
 }
wait
}

job ( ){
...
}

如果您需要存储作业的结果，请将结果分配给变量。在wait之后，您只需检查变量包含的内容。

答案 4 :(得分：9)

这里有一个替代解决方案，可插入.bashrc并用于日常单线：

function pwait() {
    while [ $(jobs -p | wc -l) -ge $1 ]; do
        sleep 1
    done
}

要使用它，所有人必须做的就是在作业和pwait调用之后放置&，该参数给出了并行进程的数量：

for i in *; do
    do_something $i &
    pwait 10
done

使用wait而不是忙于等待jobs -p的输出会更好，但似乎没有明显的解决方案等待任何给定的任务完成而不是他们所有人。

答案 5 :(得分：8)

也许尝试并行​​化实用程序而不是重写循环？我是xjobs的忠实粉丝。我一直使用xjobs在我们的网络中批量复制文件，通常是在设置新的数据库服务器时。 http://www.maier-komor.de/xjobs.html

答案 6 :(得分：6)

虽然在bash中执行此操作可能是不可能的，但您可以相当轻松地进行半右派。 bstark给出了合适的权利，但他有以下缺陷：

  • 单词拆分：您不能将任何作业传递给在其参数中使用以下任何字符的任何作业：空格，制表符，换行符，星号，问号。如果你这样做，事情可能会意外地破裂。
  • 它依赖于脚本的其余部分来不显示任何内容。如果您这样做，或者稍后您在后台发送的脚本中添加了一些东西，因为您忘记了由于他的片段而不允许使用后台工作，事情就会破裂。

另一个没有这些缺陷的近似值如下：

scheduleAll() {
    local job i=0 max=4 pids=()

    for job; do
        (( ++i % max == 0 )) && {
            wait "${pids[@]}"
            pids=()
        }

        bash -c "$job" & pids+=("$!")
    done

    wait "${pids[@]}"
}

请注意，此作业很容易适用于检查每个作业结束时的退出代码，以便您可以在作业失败时警告用户，或根据作业的数量设置scheduleAll的退出代码失败，或其他什么。

此代码的问题仅在于：

  • 它一次安排四个（在这种情况下）作业，然后等待所有四个结束。有些可能比其他工作更早完成，这将导致下一批四个工作等到上一批工作的最长时间完成。

解决上一个问题的解决方案必须使用kill -0来轮询是否有任何进程已经消失而不是wait并安排下一个作业。但是，这引入了一个小问题：在作业结束和kill -0检查是否结束之间存在竞争条件。如果作业结束并且系统上的另一个进程同时启动，则采用恰好是刚刚完成的作业的随机PID，kill -0将不会注意到您的作业已完成，事情将会发生再次休息。

bash无法提供完美的解决方案。

答案 7 :(得分：6)

如果您熟悉make命令，则大多数情况下您可以将要作为makefile运行的命令列表表达出来。例如，如果你需要在文件* .input上运行$ SOME_COMMAND，每个文件产生* .output，你可以使用makefile 

INPUT  = a.input b.input
OUTPUT = $(INPUT:.input=.output)

%.output : %.input
    $(SOME_COMMAND) $< $@

all: $(OUTPUT)

然后运行

make -j<NUMBER>

并行运行最多NUMBER个命令。

答案 8 :(得分：3)

bash的功能：

parallel ()
{
    awk "BEGIN{print \"all: ALL_TARGETS\\n\"}{print \"TARGET_\"NR\":\\n\\t@-\"\$0\"\\n\"}END{printf \"ALL_TARGETS:\";for(i=1;i<=NR;i++){printf \" TARGET_%d\",i};print\"\\n\"}" | make $@ -f - all
}

使用：

cat my_commands | parallel -j 4

答案 9 :(得分：2)

我工作的项目使用 wait 命令来控制并行shell（实际上是ksh）进程。为了解决您对IO的担忧，在现代操作系统上，并行执行可能会提高效率。如果所有进程都在磁盘上读取相同的块，则只有第一个进程必须访问物理硬件。其他进程通常能够从内存中的OS磁盘缓存中检索块。显然，从内存中读取比从磁盘读取快几个数量级。此外，该优势不需要编码更改。

答案 10 :(得分：1)

这对于大多数用途来说可能已经足够了，但并不是最佳目的​​。

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

答案 11 :(得分：1)

真的迟到了，但是这是另一个解决方案。

许多解决方案不处理命令中的空格/特殊字符，不始终保持N个作业运行，在繁忙的循环中吃cpu或依赖外部依赖项（例如GNU parallel）

使用inspiration for dead/zombie process handling，这是一个纯bash解决方案：

function run_parallel_jobs {
    local concurrent_max=$1
    local callback=$2
    local cmds=("${@:3}")
    local jobs=( )

    while [[ "${#cmds[@]}" -gt 0 ]] || [[ "${#jobs[@]}" -gt 0 ]]; do
        while [[ "${#jobs[@]}" -lt $concurrent_max ]] && [[ "${#cmds[@]}" -gt 0 ]]; do
            local cmd="${cmds[0]}"
            cmds=("${cmds[@]:1}")

            bash -c "$cmd" &
            jobs+=($!)
        done

        local job="${jobs[0]}"
        jobs=("${jobs[@]:1}")

        local state="$(ps -p $job -o state= 2>/dev/null)"

        if [[ "$state" == "D" ]] || [[ "$state" == "Z" ]]; then
            $callback $job
        else
            wait $job
            $callback $job $?
        fi
    done
}

以及示例用法：

function job_done {
    if [[ $# -lt 2 ]]; then
        echo "PID $1 died unexpectedly"
    else
        echo "PID $1 exited $2"
    fi
}

cmds=( \
    "echo 1; sleep 1; exit 1" \
    "echo 2; sleep 2; exit 2" \
    "echo 3; sleep 3; exit 3" \
    "echo 4; sleep 4; exit 4" \
    "echo 5; sleep 5; exit 5" \
)

# cpus="$(getconf _NPROCESSORS_ONLN)"
cpus=3
run_parallel_jobs $cpus "job_done" "${cmds[@]}"

输出：

1
2
3
PID 56712 exited 1
4
PID 56713 exited 2
5
PID 56714 exited 3
PID 56720 exited 4
PID 56724 exited 5

对于每个进程的输出，$$可以用于登录到文件，例如：

function job_done {
    cat "$1.log"
}

cmds=( \
    "echo 1 \$\$ >\$\$.log" \
    "echo 2 \$\$ >\$\$.log" \
)

run_parallel_jobs 2 "job_done" "${cmds[@]}"

输出：

1 56871
2 56872

答案 12 :(得分：0)

你可以使用一个简单的嵌套for循环（用下面的N和M替换适当的整数）：

for i in {1..N}; do
  (for j in {1..M}; do do_something; done & );
done

这将在M轮中执行do_meome N * M次，每轮并行执行N个作业。您可以使N等于您拥有的CPU数量。

答案 13 :(得分：0)

以下是我在bash脚本中设法解决此问题的方法：

 #! /bin/bash

 MAX_JOBS=32

 FILE_LIST=($(cat ${1}))

 echo Length ${#FILE_LIST[@]}

 for ((INDEX=0; INDEX < ${#FILE_LIST[@]}; INDEX=$((${INDEX}+${MAX_JOBS})) ));
 do
     JOBS_RUNNING=0
     while ((JOBS_RUNNING < MAX_JOBS))
     do
         I=$((${INDEX}+${JOBS_RUNNING}))
         FILE=${FILE_LIST[${I}]}
         if [ "$FILE" != "" ];then
             echo $JOBS_RUNNING $FILE
             ./M22Checker ${FILE} &
         else
             echo $JOBS_RUNNING NULL &
         fi
         JOBS_RUNNING=$((JOBS_RUNNING+1))
     done
     wait
 done

答案 14 :(得分：0)

我的解决方案是始终保持一定数量的进程运行，跟踪错误并处理不可中断/僵尸进程：

function log {
    echo "$1"
}

# Take a list of commands to run, runs them sequentially with numberOfProcesses commands simultaneously runs
# Returns the number of non zero exit codes from commands
function ParallelExec {
    local numberOfProcesses="${1}" # Number of simultaneous commands to run
    local commandsArg="${2}" # Semi-colon separated list of commands

    local pid
    local runningPids=0
    local counter=0
    local commandsArray
    local pidsArray
    local newPidsArray
    local retval
    local retvalAll=0
    local pidState
    local commandsArrayPid

    IFS=';' read -r -a commandsArray <<< "$commandsArg"

    log "Runnning ${#commandsArray[@]} commands in $numberOfProcesses simultaneous processes."

    while [ $counter -lt "${#commandsArray[@]}" ] || [ ${#pidsArray[@]} -gt 0 ]; do

        while [ $counter -lt "${#commandsArray[@]}" ] && [ ${#pidsArray[@]} -lt $numberOfProcesses ]; do
            log "Running command [${commandsArray[$counter]}]."
            eval "${commandsArray[$counter]}" &
            pid=$!
            pidsArray+=($pid)
            commandsArrayPid[$pid]="${commandsArray[$counter]}"
            counter=$((counter+1))
        done


        newPidsArray=()
        for pid in "${pidsArray[@]}"; do
            # Handle uninterruptible sleep state or zombies by ommiting them from running process array (How to kill that is already dead ? :)
            if kill -0 $pid > /dev/null 2>&1; then
                pidState=$(ps -p$pid -o state= 2 > /dev/null)
                if [ "$pidState" != "D" ] && [ "$pidState" != "Z" ]; then
                    newPidsArray+=($pid)
                fi
            else
                # pid is dead, get it's exit code from wait command
                wait $pid
                retval=$?
                if [ $retval -ne 0 ]; then
                    log "Command [${commandsArrayPid[$pid]}] failed with exit code [$retval]."
                    retvalAll=$((retvalAll+1))
                fi
            fi
        done
        pidsArray=("${newPidsArray[@]}")

        # Add a trivial sleep time so bash won't eat all CPU
        sleep .05
    done

    return $retvalAll
}

用法：

cmds="du -csh /var;du -csh /tmp;sleep 3;du -csh /root;sleep 10; du -csh /home"

# Execute 2 processes at a time
ParallelExec 2 "$cmds"

# Execute 4 processes at a time
ParallelExec 4 "$cmds"

答案 15 :(得分：-1)

$ DOMAINS =“命令中某些域的列表” for {foo in some-command 做

eval `some-command for $DOMAINS` &

    job[$i]=$!

    i=$(( i + 1))

完成

Ndomains = echo $DOMAINS |wc -w

for $ in $（seq 1 1 $ Ndomains） 做   echo“等待$ {job [$ i]}”   等“$ {job [$ i]}” 完成

在这个概念中将适用于并行化。重要的是eval的最后一行是'＆amp;' 这将把命令放到背景中。

相关问题
最新问题