использование параллельного для обработки уникальных входных файлов к уникальным выходным файлам

Стандартный способ сделать это должно установить очередь и породить любое число рабочих, которые знают, как вытянуть что-то от очереди и обработать ее. Можно использовать FIFO (иначе именованный канал) для коммуникации между этими процессами.

Ниже наивный пример для демонстрации понятия.

Простой сценарий очереди:

#!/bin/sh
mkfifo /tmp/location-queue
for i in inputfiles/*; do
  echo $i > /tmp/location-queue
done
rm /tmp/location-queue

И рабочий:

#!/bin/sh
while read file < /tmp/location-queue; do
  process_file "$file"
done

process_file мог быть определен где-нибудь в Вашем рабочем, и это может сделать то, что Вам нужен он, чтобы сделать.

После того как у Вас есть те две части, у Вас может быть простой монитор, который запускает процесс очереди и любое количество рабочих процессов.

Сценарий монитора:

#!/bin/sh
queue.sh &
num_workers="$1"
i=0
while [ $i < $num_workers ]; do
  worker.sh &
  echo $! >> /tmp/worker.pids
  i=$((i+1))
done
monitor_workers

Там у Вас есть он. Если Вы на самом деле делаете это, лучше установить FIFO в мониторе и передать путь и к очереди и к рабочим, таким образом, они не связываются и не придерживаются определенное местоположение для FIFO. Я установил его этот путь в ответе конкретно, таким образом, ясно, что, что Вы используете, поскольку Вы читаете его.

Обычно доступный инструмент, который может сделать распараллеливание, делают. GNU делает, и у немногих других есть a -j опция выполнить параллельные сборки.

.SUFFIXES: .input .output
.input.output:
        process_one_file <$< >$@.tmp
        mv -f $@.tmp $@

Выполненный make как это (я принимаю, Ваши имена файлов не содержат специальных символов, make бесполезно с теми):

make -j 4 $(for x in *.input; do echo ${x%.*}.output; done)

Это должно выполнить ту же команду на большом наборе файлов в текущем каталоге:

#!/bin/sh
trap 'worker=`expr $worker - 1`' USR1  # free up a worker
worker=0  # current worker
num_workers=10  # maximum number of workers
for file in *.txt; do
    if [ $worker -lt $num_workers ]; then
        {   customScript -c 33 -I -file $file -a -v 55 > `basename $file .txt`.outtxt 
            kill -USR1 $$ 2>/dev/null  # signal parent that we're free
        } &
        echo $worker/$num_worker $! $file  # feedback to caller
        worker=`expr $worker + 1`
    else
        wait # for a worker to finish
    fi
done

Это работает customScript на каждом txt файл, вставляя вывод outtxt файлы. Изменение, как Вам нужно. Ключ к тому, чтобы заставлять это работать является обработкой сигналов, с помощью SIGUSR1, таким образом, дочерний процесс может позволить родительскому процессу знать, что это сделано. Используя SIGCHLD не будет работать, так как большинство операторов в сценарии сгенерирует сигналы SIGCHLD к сценарию оболочки. Я попробовал эту замену Вашей команды sleep 1, программа использовала 0,28 с пользовательского CPU и 0,14 с системного CPU; это было только приблизительно на 400 файлах.

Другой пример:

ls *.txt | parallel 'sort {} > {.}.sorted.txt'

Я нашел другие примеры излишне сложными, когда в большинстве случаев вышеприведенный пример - это то, что вы, возможно, искали.

Или просто используйте xargs -P,нет необходимости устанавливать дополнительное ПО:

find. -type f -print0 | xargs -0 -I'XXX' -P4 -n1 custom_script -input "XXX" -output "XXX.out"

Немного пояснений к опциям:

• -I'XXX'задает строку, которая будет заменена в шаблоне команды именем файла
• -P4будет запускать 4 процесса параллельно
• -n1будет помещать только один файл на выполнение, даже если найдено два XXX
• -print0и -0работают вместе, позволяя использовать специальные символы. (как пробелы )в именах файлов