PricingLoginStart free
Linux-kommandolinjen og Bash-scripting på ekspertniveau · Lektion

Orkestrering af arbejdsbelastninger med GNU parallel

Fordel store inputmængder på tværs af CPU-kerner med GNU parallel, jobpladser og ordnede resultater.

Lektion 3 af 413 trin

Orkestrering af arbejdsbelastninger med GNU parallel er en gratis Linux-kommandolinjen og Bash-scripting på ekspertniveau-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Linux-kommandolinjen og Bash-scripting på ekspertniveau, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Linux-kommandolinjen og Bash-scripting på ekspertniveau-kurset indeholder 4 lektioner i alt.

Hvad er GNU parallel, og hvorfor skal du bruge det?

GNU parallel er et shell-værktøj, der lader dig køre job parallelt på én eller flere maskiner. I stedet for at behandle en stor liste med elementer ét ad gangen i en for-løkke fordeler parallel arbejdet på alle tilgængelige CPU-kerner samtidig.

  • Hastighed: En opgave, der tager 8 minutter sekventielt, kan blive færdig på cirka 1 minut på en maskine med 8 kerner.
  • Enkelhed: Den accepterer input fra stdin, filer eller argumentlister — uden manuel processtyring.
  • Sikkerhed: Output fra forskellige job holdes adskilt, så resultater aldrig blandes sammen.

Installér den med sudo apt install parallel (Debian/Ubuntu) eller brew install parallel (macOS). Kontrollér installationen med parallel --version.

Din første parallel-kommando

Den enkleste form af parallel læser elementer fra stdin og kører en kommando for hvert element. Pladsholderen {} repræsenterer det aktuelle inputelement.

Eksemplet nedenfor komprimerer fem logfiler samtidig ved hjælp af gzip. Uden parallel ville hver fil blive komprimeret efter den anden. Med parallel komprimeres op til N filer (hvor N = antallet af CPU-kerner) samtidig.

#!/usr/bin/env bash
# Create sample files first
for i in 1 2 3 4 5; do
  dd if=/dev/urandom bs=1M count=2 of="log_${i}.txt" 2>/dev/null
done

# Compress all of them in parallel
ls log_*.txt | parallel gzip {}

echo "Done. Compressed files:"
ls log_*.txt.gz

Styr jobpladser med -j

Som standard kører parallel ét job pr. CPU-kerne. Du kan tilsidesætte dette med flaget -j (eller --jobs).

  • -j 4 — kør præcis 4 job samtidig
  • -j 0 — kør lige så mange job, som der er inputelementer (brug det med omtanke!)
  • -j 200% — kør dobbelt så mange job, som der er CPU-kerner (nyttigt ved I/O-begrænsede opgaver)
  • -j 50% — brug kun halvdelen af de tilgængelige kerner

Til CPU-begrænsede opgaver er -j $(nproc) ofte optimalt. Til netværks- eller disk-I/O-opgaver kan du roligt overskride antallet af kerner, fordi job bruger det meste af tiden på at vente.

#!/usr/bin/env bash
# Show how many cores are available
echo "CPU cores: $(nproc)"

# Run 8 sleep jobs but limit to 3 at a time
# -j 3 means at most 3 jobs run simultaneously
seq 1 8 | parallel -j 3 'echo "Starting job {}"; sleep 1; echo "Done job {}"'

echo "All jobs finished."

Læs input fra filer og argumenter

parallel er fleksibel med hensyn til, hvor den læser sin inputliste. Du er ikke begrænset til at pipe fra stdin.

  • Fra en fil: parallel -a urls.txt wget {}
  • Indlejret argumentliste: parallel echo ::: apple banana cherry
  • Flere argumentkilder (kartesisk produkt): parallel echo {1}-{2} ::: a b c ::: 1 2 — producerer a-1, a-2, b-1, b-2, c-1, c-2
  • Eksplicit fra stdin: cat list.txt | parallel -j4 process {}

Skilletegnet ::: fortæller parallel, at de efterfølgende værdier skal bruges som en argumentkilde i stedet for at læse fra stdin.

#!/usr/bin/env bash
# Inline list with :::
parallel echo 'Hello from {}' ::: Alice Bob Carol Dave

echo '---'

# Cartesian product: combine two lists
# Generates: dev-v1, dev-v2, prod-v1, prod-v2
parallel echo 'Deploy {1} to env {2}' ::: v1 v2 ::: dev prod

Pladsholdere: Manipulér inputelementer

parallel tilbyder flere pladsholderudvidelser, som automatisk lader dig udtrække dele af inputstrengen — meget nyttigt, når inputtet er filstier.

  • {} — hele inputelementet
  • {.} — input uden filtypenavnet (report.csv → report)
  • {/} — kun basisnavnet (fjerner mappestien)
  • {//} — kun mappestien
  • {/.} — basisnavnet uden filtypenavn

Disse erstatter behovet for kald til basename / dirname inde i jobkommandoen, så pipelines bliver renere og hurtigere.

#!/usr/bin/env bash
# Demonstrate placeholder substitutions
parallel --dry-run 'convert {} -resize 800x600 {.}_thumb.jpg' \
  ::: /photos/vacation/beach.png /photos/work/team.png

# {.}  strips extension: /photos/vacation/beach
# Result command shown (--dry-run does NOT execute):
#  convert /photos/vacation/beach.png -resize 800x600 /photos/vacation/beach_thumb.jpg
#  convert /photos/work/team.png      -resize 800x600 /photos/work/team_thumb.jpg
echo 'No files were changed (dry run)'

Bevar outputrækkefølgen med --keep-order

Når job bliver færdige på forskellige tidspunkter, vises deres stdout-output i den rækkefølge, de afsluttes i. Det kan gøre logfiler svære at læse og efterfølgende fortolkning upålidelig.

To flag styrer outputrækkefølgen:

  • --keep-order (-k) — udskriver outputtet fra hvert job i samme rækkefølge som inputtet, selv hvis et senere job bliver færdigt først. Outputtet gemmes i en buffer, indtil tidligere job er færdige.
  • --line-buffer — en mellemvej: udskriver hele linjer, efterhånden som de ankommer, uden at vente på, at jobbet bliver færdigt, men blander aldrig halve linjer sammen.

Brug -k, når den efterfølgende modtager forventer resultaterne i inputrækkefølge (f.eks. ved opbygning af en sorteret rapport). Udelad det, når rækkefølgen er ligegyldig, og du vil se resultaterne så hurtigt som muligt.

#!/usr/bin/env bash
# Without -k: output order is unpredictable
echo '--- Without --keep-order ---'
seq 5 1 1 | parallel 'sleep 0.$((RANDOM % 5)); echo "Result for {}"'

echo

# With -k: output always appears as 5, 4, 3, 2, 1
echo '--- With --keep-order (-k) ---'
seq 5 1 1 | parallel -k 'sleep 0.$((RANDOM % 5)); echo "Result for {}"'

Gruppering af uddata for at undgå sammenblanding

Selv med ordnet uddata kan linjerne blive blandet sammen med linjer fra en anden opgave, der kører samtidig, hvis en opgave udskriver flere linjer. parallel løser automatisk dette ved at gemme hver opgaves samlede stdout og stderr i en buffer og derefter udskrive dem som én samlet, atomisk blok, når opgaven er færdig.

Denne funktionsmåde er aktiveret som standard. Du kan deaktivere den med --ungroup, hvis du har brug for direkte, løbende uddata (f.eks. ved langvarige opgaver med statusbjælker), men så kan uddata igen blive blandet sammen.

  • Standard: uddata grupperes pr. opgave — sikkert at fortolke.
  • --ungroup: uddata sendes løbende — velegnet til interaktiv overvågning.
  • --line-buffer: kompromis — linjer deles aldrig, men opgaver kan blandes sammen ved linjeskift.

Overførsel af argumenter i shell-funktioner

Nogle gange består det arbejde, du vil køre parallelt, af mere end én kommando — det er en shell-funktion med flere trin. Du kan overføre en funktion til parallel ved at kombinere export -f med env_parallel eller ved at kalde bash -c direkte.

Den sikreste portable tilgang til komplekse opgaver er mønsteret bash -c '...'. Pladsholderen {} overføres som $1, når du afslutter med _ {}.

#!/usr/bin/env bash
# Define a multi-step processing function
process_item() {
  local item="$1"
  echo "[START] $item"
  # Simulate two steps
  sleep 0.2
  local result=$(echo "$item" | tr '[:lower:]' '[:upper:]')
  echo "[END]   $item -> $result"
}

export -f process_item

# Run the function in parallel for each input
echo 'alpha beta gamma delta epsilon' | tr ' ' '\n' \
  | parallel -j 3 process_item {}

Begrænsning af hastighed og gentagelse med --delay og --retries

Når du tilgår eksterne tjenester (API'er, fjernservere, databaser) parallelt, har du ofte brug for hastighedsbegrænsning og fejltolerance.

  • --delay N — vent N sekunder mellem starten på hver ny opgave (brøkdele som 0.5 er tilladt). Forhindrer overbelastning af en tjeneste.
  • --retries N — hvis en opgave afsluttes med en status, der ikke er nul, køres den igen op til N gange, før den opgives. Hver gentagelse tæller som en ny opgaveplads.
  • --timeout N — afslut en opgave, hvis den kører længere end N sekunder. Sammen med --retries håndterer dette hængende opgaver på en kontrolleret måde.

Eksempel: Hentning af 50 URL'er med højst 4 samtidige forbindelser, en opstarts-forsinkelse på 0,5 sekunder mellem starterne og 3 gentagelser ved fejl.

#!/usr/bin/env bash
# Simulate downloading URLs with throttling and retries
# (using echo instead of curl so this is self-contained)

download_url() {
  local url="$1"
  # Randomly fail ~30% of the time to demo --retries
  if (( RANDOM % 10 < 3 )); then
    echo "FAIL: $url" >&2
    return 1
  fi
  echo "OK:   $url downloaded"
}

export -f download_url

printf 'https://example.com/file%d\n' $(seq 1 10) \
  | parallel -j 4 --delay 0.2 --retries 3 download_url {}

echo 'All downloads attempted.'

Fordeling af arbejde på fjernværter med --sshloginfile

parallel kan ubemærket fordele opgaver på fjernmaskiner via SSH og fungerer dermed som et letvægtsværktøj til klyngeberegning uden særlig klyngesoftware.

  • --sshlogin user@host — kør opgaver på en bestemt fjernvært.
  • --sshloginfile machines.txt — læs en liste over værter fra en fil (én pr. linje). Brug : som en særlig post for også at bruge den lokale maskine.
  • --transfer — kopiér inddatafilen til fjernværten før behandlingen.
  • --return {} — kopiér resultatfilen tilbage, når opgaven er færdig.
  • --cleanup — slet overførte filer fra fjernværten efter hentningen.

Fjernværten skal have parallel installeret og SSH-godkendelse baseret på nøgler konfigureret (uden anmodninger om adgangskoder).

Statusrapportering og logning

For langvarige arbejdsbelastninger er det vigtigt at overvåge fremdriften og diagnosticere fejl efterfølgende.

  • --progress — udskriver en løbende oversigtslinje, der viser, hvor mange opgaver der kører, er færdige og mangler.
  • --eta — estimerer tiden til færdiggørelse ud fra den gennemsnitlige opgavevarighed indtil videre.
  • --joblog results.log — skriver en tabulatorsepareret logfil med én række pr. færdig opgave, herunder afslutningskode, køretid og den kørte kommando. Uundværlig ved fejlgennemgang.
  • --resume --joblog results.log — springer opgaver over, som allerede findes (med afslutningskode 0) i logfilen. Hvis en batchkørsel afbrydes, kan du genoptage den uden at gentage vellykket arbejde.

Kombinationen --joblog + --resume er en af de mest effektive funktioner i GNU parallel til robuste produktionsdatabehandlingskæder.

#!/usr/bin/env bash
LOGFILE="/tmp/parallel_demo_$$.log"

# Run jobs and record results to a log
seq 1 12 | parallel \
  --jobs 4 \
  --progress \
  --joblog "$LOGFILE" \
  'sleep 0.1; echo "Processed item {}"'

echo
echo '=== Job Log (first 5 entries) ==='
head -6 "$LOGFILE"

# Show only failed jobs (exit value != 0)
echo '=== Failed jobs ==='
awk 'NR>1 && $7 != 0 { print $0 }' "$LOGFILE" || echo '(none)'

rm -f "$LOGFILE"

Videnstjek: Flag til opgavepladser

Test din forståelse af, hvordan parallel styrer samtidighed.

Besvar den i den interaktive lektion

Opsummering af lektionen: Orkestrering af arbejdsbelastninger med GNU parallel

Du har gennemgået de vigtigste værktøjer til at fordele store inddatasæt på CPU-kerner med GNU parallel. Her er det vigtigste:

  • Grundlæggende brug: send en liste gennem en pipe til parallel command {} — {} erstattes af hvert inddataelement.
  • Opgavepladser (-j): styr samtidigheden præcist — brug antallet af kerner til CPU-begrænset arbejde og højere procentdele til I/O-begrænset arbejde.
  • Pladsholdere ({.}, {/}, {//}, {/.}) udtrækker sti-komponenter uden ekstra kommandoer.
  • Styring af uddata: -k bevarer inddatarækkefølgen; standardgruppering forhindrer sammenblandede linjer; --ungroup giver løbende uddata.
  • Robusthed: --retries, --timeout og --delay gør parallelle databehandlingskæder robuste over for ustabile opgaver og hastighedsbegrænsninger.
  • Efterprøvbarhed: --joblog registrerer resultatet af hver opgave; --resume lader dig fortsætte, hvor du slap, efter en afbrydelse.
  • Udskalering: --sshloginfile fordeler opgaver på fjernmaskiner via SSH uden ekstra klyngeoverhead.

Når du behersker disse indstillinger, bliver parallel til en produktionsklar orkestrator for arbejdsbelastninger, indbygget direkte i din shell.

Gratis at komme i gang

Lær Bash med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser
22
Lektioner
88
Start gratisSe hele kurset

Ofte stillede spørgsmål

Er lektionen “Orkestrering af arbejdsbelastninger med GNU parallel” gratis?

Ja — hele teksten til “Orkestrering af arbejdsbelastninger med GNU parallel” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Linux-kommandolinjen og Bash-scripting på ekspertniveau-kurset, skal du opgradere til CoddyKit PRO. Linux-kommandolinjen og Bash-scripting på ekspertniveau-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Orkestrering af arbejdsbelastninger med GNU parallel”?

Fordel store inputmængder på tværs af CPU-kerner med GNU parallel, jobpladser og ordnede resultater. Du øver dig i Linux-kommandolinjen og Bash-scripting på ekspertniveau med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Linux-kommandolinjen og Bash-scripting på ekspertniveau?

Der kræves ingen tidligere erfaring. Linux-kommandolinjen og Bash-scripting på ekspertniveau på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “Orkestrering af arbejdsbelastninger med GNU parallel”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Linux-kommandolinjen og Bash-scripting på ekspertniveau-lektion?

Ja. Alle Linux-kommandolinjen og Bash-scripting på ekspertniveau-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

  1. Profilering af scripts og undgåelse af overflødige subshells
  2. Parallelisme med xargs -P og baggrundsjob
  3. Orkestrering af arbejdsbelastninger med GNU parallel
  4. Streaming-pipelines og navngivne pipes for høj kapacitet
← Tilbage til Linux-kommandolinjen og Bash-scripting på ekspertniveau