Tôi đã cố gắng song song hóa tập lệnh sau, cụ thể là từng trường hợp trong ba trường hợp vòng lặp FOR, sử dụng GNU Parallel nhưng không thể thực hiện được. 4 lệnh chứa trong vòng lặp FOR chạy theo chuỗi, mỗi vòng lặp mất khoảng 10 phút.

#!/bin/bash

kar='KAR5'
runList='run2 run3 run4'
mkdir normFunc
for run in $runList
do 
  fsl5.0-flirt -in $kar"deformed.nii.gz" -ref normtemp.nii.gz -omat $run".norm1.mat" -bins 256 -cost corratio -searchrx -90 90 -searchry -90 90 -searchrz -90 90 -dof 12 
  fsl5.0-flirt -in $run".poststats.nii.gz" -ref $kar"deformed.nii.gz" -omat $run".norm2.mat" -bins 256 -cost corratio -searchrx -90 90 -searchry -90 90 -searchrz -90 90 -dof 12 
  fsl5.0-convert_xfm -concat $run".norm1.mat" -omat $run".norm.mat" $run".norm2.mat"
  fsl5.0-flirt -in $run".poststats.nii.gz" -ref normtemp.nii.gz -out $PWD/normFunc/$run".norm.nii.gz" -applyxfm -init $run".norm.mat" -interp trilinear

  rm -f *.mat
done

Tại sao bạn không chỉ rẽ nhánh (còn gọi là nền) chúng?

foo () {
    local run=$1
    fsl5.0-flirt -in $kar"deformed.nii.gz" -ref normtemp.nii.gz -omat $run".norm1.mat" -bins 256 -cost corratio -searchrx -90 90 -searchry -90 90 -searchrz -90 90 -dof 12 
    fsl5.0-flirt -in $run".poststats.nii.gz" -ref $kar"deformed.nii.gz" -omat $run".norm2.mat" -bins 256 -cost corratio -searchrx -90 90 -searchry -90 90 -searchrz -90 90 -dof 12 
    fsl5.0-convert_xfm -concat $run".norm1.mat" -omat $run".norm.mat" $run".norm2.mat"
    fsl5.0-flirt -in $run".poststats.nii.gz" -ref normtemp.nii.gz -out $PWD/normFunc/$run".norm.nii.gz" -applyxfm -init $run".norm.mat" -interp trilinear
}

for run in $runList; do foo "$run" & done

Trong trường hợp không rõ ràng, phần quan trọng là ở đây:

for run in $runList; do foo "$run" & done
                                   ^

Làm cho hàm được thực thi trong một shell fork trong nền. Đó là song song.

Nhiệm vụ mẫu

task(){
   sleep 0.5; echo "$1";
}

Chạy tuần tự

for thing in a b c d e f g; do 
   task "$thing"
done

Chạy song song

for thing in a b c d e f g; do 
  task "$thing" &
done

Chạy song song trong các lô N-process

N=4
(
for thing in a b c d e f g; do 
   ((i=i%N)); ((i++==0)) && wait
   task "$thing" & 
done
)

Bạn cũng có thể sử dụng FIFO làm semaphores và sử dụng chúng để đảm bảo rằng các quy trình mới được sinh ra càng sớm càng tốt và không có nhiều hơn N quy trình chạy cùng một lúc. Nhưng nó đòi hỏi nhiều mã hơn.

N xử lý với một semaphore dựa trên FIFO:

open_sem(){
    mkfifo pipe-$$
    exec 3<>pipe-$$
    rm pipe-$$
    local i=$1
    for((;i>0;i--)); do
        printf %s 000 >&3
    done
}
run_with_lock(){
    local x
    read -u 3 -n 3 x && ((0==x)) || exit $x
    (
     ( "$@"; )
    printf '%.3d' $? >&3
    )&
}

N=4
open_sem $N
for thing in {a..g}; do
    run_with_lock task $thing
done 

for stuff in things
do
( something
  with
  stuff ) &
done
wait # for all the something with stuff

Cho dù nó thực sự hoạt động phụ thuộc vào các lệnh của bạn; Tôi không quen thuộc với họ. Các rm *.mattrông hơi dễ bị xung đột nếu nó chạy song song ...

for stuff in things
do
sem -j+0 ( something
  with
  stuff )
done
sem --wait

Điều này sẽ sử dụng semaphores, song song nhiều lần lặp như số lượng lõi có sẵn (-j +0 có nghĩa là bạn sẽ song song hóa các công việc N + 0 , trong đó N là số lượng lõi có sẵn ).

sem --wait nói chờ cho đến khi tất cả các lần lặp trong vòng lặp for đã chấm dứt thực thi trước khi thực hiện các dòng mã liên tiếp.

Lưu ý: bạn sẽ cần "song song" từ dự án song song GNU (sudo apt-get install song song).

Một cách thực sự dễ dàng mà tôi thường sử dụng:

cat "args" | xargs -P $NUM_PARALLEL command

Điều này sẽ chạy lệnh, chuyển qua từng dòng của tệp "args", song song, chạy tối đa $ NUM_PARALLEL cùng một lúc.

Bạn cũng có thể xem xét tùy chọn -I cho xargs, nếu bạn cần thay thế các đối số đầu vào ở các vị trí khác nhau.

Có vẻ như các công việc fsl phụ thuộc vào nhau, vì vậy 4 công việc không thể chạy song song. Việc chạy, tuy nhiên, có thể được chạy song song.

Tạo một hàm bash chạy một lần chạy và chạy hàm đó song song:

#!/bin/bash

myfunc() {
    run=$1
    kar='KAR5'
    mkdir normFunc
    fsl5.0-flirt -in $kar"deformed.nii.gz" -ref normtemp.nii.gz -omat $run".norm1.mat" -bins 256 -cost corratio -searchrx -90 90 -searchry -90 90 -searchrz -90 90 -dof 12 
    fsl5.0-flirt -in $run".poststats.nii.gz" -ref $kar"deformed.nii.gz" -omat $run".norm2.mat" -bins 256 -cost corratio -searchrx -90 90 -searchry -90 90 -searchrz -90 90 -dof 12 
    fsl5.0-convert_xfm -concat $run".norm1.mat" -omat $run".norm.mat" $run".norm2.mat"
    fsl5.0-flirt -in $run".poststats.nii.gz" -ref normtemp.nii.gz -out $PWD/normFunc/$run".norm.nii.gz" -applyxfm -init $run".norm.mat" -interp trilinear
}

export -f myfunc
parallel myfunc ::: run2 run3 run4

Để tìm hiểu thêm, hãy xem các video giới thiệu: https://www.youtube.com/playlist?list=PL284C9FF2488BC6D1 và dành một giờ đi bộ qua hướng dẫn http://www.gnu.org/software/abul/abul_tutorial.html Lệnh của bạn dòng sẽ yêu bạn cho nó.

Thực hiện song song trong đồng thời quá trình N tối đa

#!/bin/bash

N=4

for i in {a..z}; do
    (
        # .. do your stuff here
        echo "starting task $i.."
        sleep $(( (RANDOM % 3) + 1))
    ) &

    # allow only to execute $N jobs in parallel
    if [[ $(jobs -r -p | wc -l) -gt $N ]]; then
        # wait only for first job
        wait -n
    fi

done

# wait for pending jobs
wait

echo "all done"

Tôi thực sự thích câu trả lời từ @lev vì nó cung cấp quyền kiểm soát số lượng quy trình tối đa một cách rất đơn giản. Tuy nhiên như được mô tả trong hướng dẫn , sem không hoạt động với dấu ngoặc.

for stuff in things
do
sem -j +0 "something; \
  with; \
  stuff"
done
sem --wait

Làm công việc.

-j + N Thêm N vào số lõi CPU. Chạy đến nhiều công việc này song song. Đối với các công việc chuyên sâu tính toán -j +0 rất hữu ích vì nó sẽ chạy các công việc số lượng lõi cùng một lúc.

-j -N Trừ N từ số lõi CPU. Chạy đến nhiều công việc này song song. Nếu số lượng đánh giá nhỏ hơn 1 thì 1 sẽ được sử dụng. Xem thêm - sử dụng-cpus-thay vì lõi.

Trong trường hợp của tôi, tôi không thể sử dụng semaphore (tôi đang sử dụng git-bash trên Windows), vì vậy tôi đã nghĩ ra một cách chung để phân chia nhiệm vụ giữa N worker, trước khi chúng bắt đầu.

Nó hoạt động tốt nếu các nhiệm vụ mất khoảng thời gian như nhau. Nhược điểm là, nếu một trong những công nhân mất nhiều thời gian để thực hiện phần công việc của mình, thì những người khác đã hoàn thành sẽ không giúp được gì.

Chia công việc giữa N công nhân (1 mỗi lõi)

# array of assets, assuming at least 1 item exists
listAssets=( {a..z} ) # example: a b c d .. z
# listAssets=( ~/"path with spaces/"*.txt ) # could be file paths

# replace with your task
task() { # $1 = idWorker, $2 = asset
  echo "Worker $1: Asset '$2' START!"
  # simulating a task that randomly takes 3-6 seconds
  sleep $(( ($RANDOM % 4) + 3 ))
  echo "    Worker $1: Asset '$2' OK!"
}

nVirtualCores=$(nproc --all)
nWorkers=$(( $nVirtualCores * 1 )) # I want 1 process per core

worker() { # $1 = idWorker
  echo "Worker $1 GO!"
  idAsset=0
  for asset in "${listAssets[@]}"; do
    # split assets among workers (using modulo); each worker will go through
    # the list and select the asset only if it belongs to that worker
    (( idAsset % nWorkers == $1 )) && task $1 "$asset"
    (( idAsset++ ))
  done
  echo "    Worker $1 ALL DONE!"
}

for (( idWorker=0; idWorker<nWorkers; idWorker++ )); do
  # start workers in parallel, use 1 process for each
  worker $idWorker &
done
wait # until all workers are done

Tôi gặp rắc rối với @PSkocikgiải pháp của. Hệ thống của tôi không có sẵn GNU Parallel dưới dạng gói và semđã tạo một ngoại lệ khi tôi xây dựng và chạy nó bằng tay. Sau đó, tôi đã thử ví dụ semaphore FIFO cũng đã đưa ra một số lỗi khác liên quan đến giao tiếp.

@eyeApps xargs đề xuất nhưng tôi không biết làm thế nào để nó hoạt động với trường hợp sử dụng phức tạp của mình (ví dụ sẽ được chào đón).

Đây là giải pháp của tôi cho các công việc song song xử lý các Ncông việc tại một thời điểm như được định cấu hình bởi _jobs_set_max_parallel:

_lib_jobs.sh:

function _jobs_get_count_e {
   jobs -r | wc -l | tr -d " "
}

function _jobs_set_max_parallel {
   g_jobs_max_jobs=$1
}

function _jobs_get_max_parallel_e {
   [[ $g_jobs_max_jobs ]] && {
      echo $g_jobs_max_jobs

      echo 0
   }

   echo 1
}

function _jobs_is_parallel_available_r() {
   (( $(_jobs_get_count_e) < $g_jobs_max_jobs )) &&
      return 0

   return 1
}

function _jobs_wait_parallel() {
   # Sleep between available jobs
   while true; do
      _jobs_is_parallel_available_r &&
         break

      sleep 0.1s
   done
}

function _jobs_wait() {
   wait
}

Ví dụ sử dụng:

#!/bin/bash

source "_lib_jobs.sh"

_jobs_set_max_parallel 3

# Run 10 jobs in parallel with varying amounts of work
for a in {1..10}; do
   _jobs_wait_parallel

   # Sleep between 1-2 seconds to simulate busy work
   sleep_delay=$(echo "scale=1; $(shuf -i 10-20 -n 1)/10" | bc -l)

   ( ### ASYNC
   echo $a
   sleep ${sleep_delay}s
   ) &
done

# Visualize jobs
while true; do
   n_jobs=$(_jobs_get_count_e)

   [[ $n_jobs = 0 ]] &&
      break

   sleep 0.1s
done