并行运行两个顺序bash脚本4次

Question

我有一个配置文件列表：

cfg1.cfg
cfg2.cfg
cfg3.cfg
cfg4.cfg
cfg5.cfg
cfg6.cfg
cfg7.cfg
...

作为两个脚本的输入：

script1.sh
script2.sh

我依次运行如下：

script1.sh cfgX.cfg && script2.sh cfgX.cfg

其中X=1，2，3，.

这些脚本没有并行化，需要很长时间才能运行。我如何并行地启动它们，比方说当时的4，这样我就不会杀死运行它们的服务器了？

对于一个脚本，我尝试了一种类似于：

export COUNTER_LIMIT=4

export COUNTER=1

for each in $(ls *.cfg)
do

INSTRUCTION="./script1.sh $each "

if (($COUNTER >= $COUNTER_LIMIT)) ; 
then
$INSTRUCTION   &&
export COUNTER=$(($COUNTER-$COUNTER_LIMIT));
echo
sleep 600s
else
$INSTRUCTION  &
sleep 5s
fi

echo $COUNTER
export COUNTER=$(($COUNTER+1));

done

(睡眠是因为某些原因，脚本不能同时启动.)

所以，我能这样做吗？

script1.sh cfgX.cfg && script2.sh cfgX.cfg

不阻止蛮力的平行化吗？

(我也接受更好和更简单的方法;)

欢呼豪尔赫

更新

我应该提到的是，配置文件不一定按顺序命名，而且可以有任何名称，我只是这样做，以使示例尽可能简单。

Answer 1

parallel --jobs 4  \
         --load 50% \
         --bar       \
         --eta "( echo 1st-for-{}; echo 2nd-for-{} )" < aListOfAdHocArguments.txt
0% 0:5=0s
1st-for-Abraca
2nd-for-Abraca
20% 1:4=0s                                                                                                                                                                                                 
1st-for-Dabra
2nd-for-Dabra
40% 2:3=0s                                                                                                                                                                                                 
1st-for-Hergot
2nd-for-Hergot
60% 3:2=0s                                                                                                                                                                                                 
1st-for-Fagot
2nd-for-Fagot
80% 4:1=0s                                                                                                                                                                                                 

100% 5:0=0s

Q：我如何并行地启动它们，假设在当时的__中是4，所以没有杀死运行它们的服务器？

GNU parallel.的可爱任务

首先，让我们检查本地主机生态系统(外部系统，在parallel-jobs over ssh-connected远程主机上执行，但超出了本文的范围)：

parallel --number-of-cpus
parallel --number-of-cores
parallel --show-limits

有关--jobs 4，之外的更多配置细节，可能包括--memfree或--noswap、--load <max-load>或--keep-order以及--results <aFile>或--output-as-files：

man parallel

parallel --jobs 4 \
         --bar     \
         --eta "( script1.sh cfg{}.cfg; script2.sh cfg{}.cfg )" ::: {1..123}

这里,

仅由一对串联Estimated-Time-of-Arrival echo-s来模拟向下计数的指数，因此进度栏是不可见的，而-s --eta指示几乎是即时的.：

parallel --jobs 4  \
         --load 50% \
         --bar       \
         --eta "( echo 1st-for-cfg-{}; echo 2nd-for-cfg-{} )" ::: {10..0}
0% 0:11=0s 7                                                                                                                                                                                               
1st-for-cfg-10
2nd-for-cfg-10
9% 1:10=0s 6                                                                                                                                                                                               
1st-for-cfg-9
2nd-for-cfg-9
18% 2:9=0s 5                                                                                                                                                                                               
1st-for-cfg-8
2nd-for-cfg-8
27% 3:8=0s 4                                                                                                                                                                                               
1st-for-cfg-7
2nd-for-cfg-7
36% 4:7=0s 3                                                                                                                                                                                               
1st-for-cfg-6
2nd-for-cfg-6
45% 5:6=0s 2                                                                                                                                                                                               
1st-for-cfg-5
2nd-for-cfg-5
54% 6:5=0s 1                                                                                                                                                                                               
1st-for-cfg-4
2nd-for-cfg-4
63% 7:4=0s 0                                                                                                                                                                                               
1st-for-cfg-3
2nd-for-cfg-3
72% 8:3=0s 0                                                                                                                                                                                               
1st-for-cfg-2
2nd-for-cfg-2
81% 9:2=0s 0                                                                                                                                                                                               
1st-for-cfg-1
2nd-for-cfg-1
90% 10:1=0s 0                                                                                                                                                                                              
1st-for-cfg-0
2nd-for-cfg-0

更新

你还说：

--我应该提到，配置文件不一定按顺序命名，可以有任何名称，我只是这样做，以使示例尽可能简单。

< list_of_arguments解决了这个事后更改的问题定义：

parallel [options] [command [arguments]] < list_of_arguments

Answer 2

对于find和xargs来说，这将相当简单。这将并行运行四个进程，对于任何给定的配置文件，在运行script1.sh之前将完成script2.sh。

find . -name '*.cfg' -print0 | xargs -0 -P 4 -iCFG sh -c 'script1.sh CFG && script2.sh CFG'

Answer 3

我做了一些模拟测试，首先我像你描述的那样创建了这个文件。

printf '%s\n' cfg{1..100}.cfg > file.txt

现在是处理它的脚本。

#!/bin/bash

file=file.txt
limit=2

array=()
while read -r cfg; do
  array+=("$cfg")
done < "$file"

for ((n=0; n<limit; n++)); do
  for ((i=n; i<${#array[@]}; i+=limit)); do
    echo script1.sh "${array[i]}" && echo script2.sh "${array[i]}" && sleep 2; echo
  done &
done

wait

现在，如果你运行那个脚本，你应该看看会发生什么。回声和睡眠只是为了视觉上的帮助:-)，如果您决定实际运行脚本，您可以删除它们。改变极限的价值，让自己的心满足。解决这个问题的想法和技巧不是我提出的。这是这个人说的。https://github.com/e36freak/，把它到期的地方记下来.