помогите с gnu parallel и bash

PARALLEL=4

my_super_function() {
    cmd args
}


jobs_is_parallel_available() {
        local -i i
        local l
        while true; do
                i=0
                while read l; do
                        i+=1
                done < <(jobs -r)
                [[ $i -lt $PARALLEL ]] && break
                sleep 0.1s
        done
}

for j in $JOB_LIST; do
   my_super_function "$j" &
   jobs_is_parallel_available
done
wait

var=$var + "
 command1 $arg1,
 commandtw $argtw1 $argtwetc,
 commandetc $argetc
"

parallel $var

C1=("cmd1" "cmd1_arg1" "cmd1_arg2" "cmd1_arg3")
C2=("cmd2" "cmd2_arg1" "cmd2_arg2" "cmd2_arg3")
C3=("cmd3" "cmd3_arg1" "cmd3_arg2" "cmd3_arg3")

CMDS=(C1 C2 C3)

for job in ${CMDS[@]}; do
        eval 'cmd=("${'$job'[@]}")'
        "${cmd[@]}"
done

$ cat my_script

#!/usr/bin/bash

if [ ! $DOIT ]; then
    export DOIT=yes
    find . -maxdepth 1 -type f -print0 | xargs -0 -n1 -P$(nproc --all) ./my_script
    exit 0
fi

FILE="$1"

очень
много
разных
команд
...

array+=("build1 $VAR1")
array+=("buildtw $VARtw")
array+=("buildetc $VARetc")

       -P max-procs, --max-procs=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
              or the -L option with -P; otherwise chances are that only one exec will be done.  While xargs is running, you can send its process a SIGUSR1 signal to  in‐
              crease  the  number  of  commands to run simultaneously, or a SIGUSR2 to decrease the number.  You cannot increase it above an implementation-defined limit
              (which is shown with --show-limits).  You cannot decrease it below 1.  xargs never terminates its commands; when asked to decrease,  it  merely  waits  for
              more than one existing command to terminate before starting another.

              Please  note  that it is up to the called processes to properly manage parallel access to shared resources.  For example, if more than one of them tries to
              print to stdout, the output will be produced in an indeterminate order (and very likely mixed up) unless the processes collaborate in some way  to  prevent
              this.   Using  some kind of locking scheme is one way to prevent such problems.  In general, using a locking scheme will help ensure correct output but re‐
              duce performance.  If you don't want to tolerate the performance difference, simply arrange for each process to produce a separate output file  (or  other‐
              wise use separate resources).

#!/bin/bash

for FILE in $(find . -maxdepth 1 -type f); do

 очень
 много
 разных
 команд
 делающих $VAR1 $VARtw $VARetc

 if [ -x "$(command -v parallel)" ]; then
  var_parallel+=("build1 $VAR1")
  var_parallel+=("buildtw $VARtw")
  var_parallel+=("buildetc $VARetc")
 else
  build1 $VAR1
  buildtw $VARtw
  buildetc $VARetc
 fi

done

if [ ! -z "$var_parallel" ]; then
  parallel ::: "${var_parallel[@]}"
fi