bash如何等待在后台运行的分叉进程的完成_Bash_Wait

bash如何等待在后台运行的分叉进程的完成

bash

bash如何等待在后台运行的分叉进程的完成,bash,wait,Bash,Wait,我想知道我是否能实现如下逻辑：给定要执行的一组作业和有限数量的工作进程，比如说，我希望并行运行work\u num进程，直到所有作业fold\u num完成。最后，对所有这些作业的结果进行其他处理。我们可以假设，折叠数始终是工作数的几倍到目前为止，我还没有找到下面的代码片段，还有来自输出如下所示： pids_idx=0, pids[0]= pids=5846 pids_idx=1, pids[1]= fold0 pids=5846 5847 fold1 pids_idx=2, pids[2

我想知道我是否能实现如下逻辑：给定要执行的一组作业和有限数量的工作进程，比如说，我希望并行运行

work\u num

进程，直到所有作业

fold\u num

完成。最后，对所有这些作业的结果进行其他处理。我们可以假设，

折叠数

始终是

工作数

的几倍

到目前为止，我还没有找到下面的代码片段，还有来自

输出如下所示：

pids_idx=0, pids[0]=
pids=5846
pids_idx=1, pids[1]=
fold0
pids=5846 5847
fold1
pids_idx=2, pids[2]=
pids=5846 5847 5848
fold2
pids_idx=3, pids[3]=
pids=5846 5847 5848 5849
fold3
pids_idx=4, pids[4]=
pids=5846 5847 5848 5849 5850
pids_idx=0, pids[0]=5846
fold4
./test_wait.sh: line 12: wait: pid 5846 is not a child of this shell
some job is abnormal, aborting

问题: 1.似乎

pids

数组已记录正确的进程ID，但未能“等待”。有没有办法解决这个问题？

2.在for循环之后是否需要使用

wait

？如果是这样的话，在for循环之后该怎么办？

好吧，我想我从“

并行

”的人们那里得到了一个有用的解决方案

export worker_names=("foo", "bar")                                                                                                                                                                                   
export worker_num=${#worker_names[@]}        

function some_computation {                                                                                                                                                                                          
    fold=$1                                                                                                                                                                                                          
    cmd="..."     #involves worker_names and fold                                                                                                                                                                    
    echo $cmd; $cmd                                                                                                                                                                                                  
}                                                                                                                                                                                                                    
export -f some_computation # important, to make this function visible to subprocesses                                                                                                                                

for fold in $(seq 0 $(( $fold_num-1 ))); do                                                                                                                                                                          
    sem -j $worker_num some_computation $fold                                                                                                                                                                        
done                                                                                                                                                                                                                 

sem --wait    # wait for all jobs to complete  

# do something below

这里有几件事：

我没有进行

并行

工作，因为在这些并行作业之后，我需要进行后期计算处理。我尝试的并行版本无法等待作业完成。所以我使用了GNU

sem

，它代表信号量

在这种情况下，导出变量对于计算函数的访问至关重要。否则，这些全局变量是不可见的

出于同样的原因，导出计算函数也是必要的。请注意

-f

选项

sem--wait

完美地满足了等待并行作业的需求

HTH.

好吧，我想我得到了一个可行的解决方案，其中有来自“

并行”

”的人的提示

export worker_names=("foo", "bar")                                                                                                                                                                                   
export worker_num=${#worker_names[@]}        

function some_computation {                                                                                                                                                                                          
    fold=$1                                                                                                                                                                                                          
    cmd="..."     #involves worker_names and fold                                                                                                                                                                    
    echo $cmd; $cmd                                                                                                                                                                                                  
}                                                                                                                                                                                                                    
export -f some_computation # important, to make this function visible to subprocesses                                                                                                                                

for fold in $(seq 0 $(( $fold_num-1 ))); do                                                                                                                                                                          
    sem -j $worker_num some_computation $fold                                                                                                                                                                        
done                                                                                                                                                                                                                 

sem --wait    # wait for all jobs to complete  

# do something below