PricingLoginStart free
Linux-komentorivin ja Bash-komentosarjojen hallinta · Oppitunti

Työkuormien orkestrointi GNU parallelilla

Jaa suuret syötejoukot suorittimien kesken GNU parallelilla, työpaikoilla ja tulosten järjestyksen säilyttämisellä.

Oppitunti 3/413 vaihetta

Työkuormien orkestrointi GNU parallelilla on ilmainen Linux-komentorivin ja Bash-komentosarjojen hallinta-oppitunti CoddyKitissä. Tämä on oppitunti 3/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Linux-komentorivin ja Bash-komentosarjojen hallinta-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Linux-komentorivin ja Bash-komentosarjojen hallinta-kurssilla on yhteensä 4 oppituntia.

Mikä GNU parallel on ja miksi sitä kannattaa käyttää?

GNU parallel on shell-työkalu, jolla voitte suorittaa töitä rinnakkain yhdellä tai usealla koneella. Sen sijaan, että käsittelisitte suuren kohdeluettelon yksi kohde kerrallaan for-silmukassa, parallel jakaa työn samanaikaisesti kaikille käytettävissä oleville suorittimen ytimille.

  • Nopeus: Tehtävä, jonka peräkkäinen suoritus kestää 8 minuuttia, voi valmistua noin minuutissa 8-ytimisellä koneella.
  • Helppous: Se hyväksyy syötettä vakiosyötteestä, tiedostoista tai argumenttiluetteloista — prosessien hallintaa ei tarvitse toteuttaa manuaalisesti.
  • Turvallisuus: Eri töiden tulosteet pidetään erillään; tulokset eivät koskaan sekoitu toisiinsa.

Asentakaa se komennolla sudo apt install parallel (Debian/Ubuntu) tai brew install parallel (macOS). Tarkistakaa asennus komennolla parallel --version.

Ensimmäinen parallel-komento

Komennon parallel yksinkertaisin muoto lukee kohteita vakiosyötteestä ja suorittaa komennon jokaiselle kohteelle. Paikanvaraaja {} edustaa parhaillaan käsiteltävää syötekohdetta.

Alla oleva esimerkki pakkaa viisi lokitiedostoa samanaikaisesti komennolla gzip. Ilman komentoa parallel kukin tiedosto pakattaisiin peräkkäin. Sen kanssa samanaikaisesti pakataan enintään N tiedostoa (missä N = suorittimen ytimien määrä).

#!/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

Työpaikkojen hallinta -j:llä

Oletusarvoisesti parallel suorittaa yhden työn kutakin suorittimen ydintä kohti. Voitte ohittaa tämän asetuksen lipulla -j (tai --jobs).

  • -j 4 — suorittaa täsmälleen 4 työtä samanaikaisesti
  • -j 0 — suorittaa yhtä monta työtä kuin syötteitä on (käyttäkää varoen!)
  • -j 200% — suorittaa kaksi kertaa niin monta työtä kuin suorittimen ytimiä on (hyödyllinen siirräntärajoitteisessa työssä)
  • -j 50% — käyttää vain puolta käytettävissä olevista ytimistä

Suoritinrajoitteisissa tehtävissä -j $(nproc) on usein optimaalinen. Verkko- tai levy-I/O:ta käyttävissä tehtävissä ytimien määrän voi turvallisesti ylittää, koska työt käyttävät suurimman osan ajasta odottamiseen.

#!/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."

Syötteen lukeminen tiedostoista ja argumenteista

parallel on joustava sen suhteen, mistä se lukee syöteluettelonsa. Syötettä ei tarvitse välittää putken kautta vakiosyötteestä.

  • Tiedostosta: parallel -a urls.txt wget {}
  • Sulautettu argumenttiluettelo: parallel echo ::: apple banana cherry
  • Useita argumenttilähteitä (karteesinen tulo): parallel echo {1}-{2} ::: a b c ::: 1 2 — tuottaa a-1, a-2, b-1, b-2, c-1, c-2
  • Nimenomaisesti vakiosyötteestä: cat list.txt | parallel -j4 process {}

Erotin ::: kertoo komennolle parallel, että seuraavia arvoja käytetään argumenttilähteenä sen sijaan, että syöte luettaisiin vakiosyötteestä.

#!/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

Paikanvaraajat: syötetunnisteiden käsittely

parallel tarjoaa useita paikanvaraajien korvauksia, joiden avulla syötemerkkijonosta voi automaattisesti poimia osia — tämä on erittäin hyödyllistä, kun syötteenä on tiedostopolkuja.

  • {} — koko syötekohde
  • {.} — syöte ilman tiedostopäätettä (report.csv → report)
  • {/} — vain perusnimi (poistaa hakemistopolun)
  • {//} — vain hakemistopolku
  • {/.} — perusnimi ilman päätettä

Näin basename- ja dirname-kutsuja ei tarvitse tehdä työkomennon sisällä, mikä tekee putkista selkeämpiä ja nopeampia.

#!/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)'

Tulosteen järjestyksen säilyttäminen --keep-order-lipulla

Kun työt valmistuvat eri aikaan, niiden stdout-tuloste näkyy valmistumisjärjestyksessä. Tämä voi vaikeuttaa lokien lukemista ja tehdä jatkokäsittelystä epäluotettavaa.

Kaksi lippua hallitsee tulosteen järjestystä:

  • --keep-order (-k) — tulostaa kunkin työn tulosteen samassa järjestyksessä kuin syöte, vaikka myöhempi työ valmistuisi ensin. Tuloste puskuroidaan, kunnes aiemmat työt valmistuvat.
  • --line-buffer — välimuoto: tulostaa kokonaiset rivit niiden saapuessa odottamatta työn valmistumista, mutta ei koskaan lomita keskeneräisiä rivejä.

Käyttäkää -k-lippua, kun seuraava käsittelijä odottaa tuloksia syötteen järjestyksessä (esimerkiksi järjestetyn raportin muodostamisessa). Jättäkää se pois, kun järjestyksellä ei ole merkitystä ja haluatte nähdä tulokset mahdollisimman pian.

#!/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 {}"'

Tulosteen ryhmittely lomittumisen estämiseksi

Vaikka tuloste olisi järjestetty, useita rivejä tulostavan työn rivit voivat lomittua samanaikaisesti suoritettavan toisen työn rivien kanssa. parallel ratkaisee tämän automaattisesti puskuroimalla kunkin työn koko stdout- ja stderr-tulosteen ja tulostamalla ne työn valmistuttua yhtenä atomisena lohkona.

Tämä toiminta on oletusarvoisesti käytössä. Voitte poistaa sen käytöstä valitsimella --ungroup, jos tarvitsette tulosteen reaaliaikaisen suoratoiston (esimerkiksi pitkään kestävissä töissä, joissa näytetään edistymispalkkeja), mutta tällöin lomittuminen on jälleen mahdollista.

  • Oletus: tuloste ryhmitellään työn mukaan — turvallinen jäsennettäväksi.
  • --ungroup: tuloste suoratoistetaan reaaliajassa — sopii vuorovaikutteiseen seurantaan.
  • --line-buffer: kompromissi — rivejä ei koskaan jaeta, mutta työt voivat lomittua rivirajoilla.

Argumenttien välittäminen shell-funktioille

Joskus rinnakkain suoritettava työ on enemmän kuin yksi komento — se on monivaiheinen shell-funktio. Voitte välittää funktion komennolle parallel yhdistämällä export -f-komennon ja env_parallel-komennon tai kutsumalla bash -c-komentoa suoraan.

Turvallisin siirrettävä lähestymistapa monimutkaisiin töihin on bash -c '...' -rakenne. Paikanhaltija {} välitetään parametrina $1, kun komento päättyy muotoon _ {}.

#!/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 {}

Suorituksen rajoittaminen ja uudelleenyritys valitsimilla --delay ja --retries

Kun ulkoisia palveluita (ohjelmointirajapintoja, etäpalvelimia tai tietokantoja) käytetään rinnakkain, tarvitaan usein nopeusrajoitusta ja vikasietoisuutta.

  • --delay N — odottaa N sekuntia ennen kunkin uuden työn käynnistämistä (murto-osat, kuten 0.5, ovat sallittuja). Estää palvelun kuormittamisen liikaa.
  • --retries N — jos työ päättyy nollasta poikkeavaan tilakoodiin, yrittää sitä uudelleen enintään N kertaa ennen luovuttamista. Jokainen uudelleenyritys lasketaan uudeksi työpaikaksi.
  • --timeout N — lopettaa työn, jos se kestää yli N sekuntia. Yhdessä valitsimen --retries kanssa tämä käsittelee jumiutuvat työt hallitusti.

Esimerkki: 50 URL-osoitteen lataaminen enintään neljällä samanaikaisella yhteydellä, 0,5 sekunnin käynnistysviiveellä ja kolmella uudelleenyrityksellä virheen sattuessa.

#!/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.'

Työn jakaminen etäkoneille valitsimella --sshloginfile

parallel voi jakaa työt läpinäkyvästi etäkoneille SSH:n kautta, jolloin se toimii kevyenä klusterilaskennan työkaluna ilman erillistä klusteriohjelmistoa.

  • --sshlogin user@host — suorittaa työt tietyllä etäkoneella.
  • --sshloginfile machines.txt — lukee koneiden luettelon tiedostosta (yksi riviä kohden). Käyttäkää erikoismerkintää :, jos haluatte käyttää myös paikallista konetta.
  • --transfer — kopioi syötetiedoston etäkoneelle ennen käsittelyä.
  • --return {} — kopioi tulostiedoston takaisin työn valmistuttua.
  • --cleanup — poistaa siirretyt tiedostot etäkoneelta noudon jälkeen.

Etäkoneelle on oltava asennettuna parallel, ja SSH-avaimiin perustuva tunnistautuminen on määritettävä (salasanakyselyjä ei saa tulla).

Edistymisen raportointi ja lokitus

Pitkään kestävien työkuormien yhteydessä edistymistä on tärkeää seurata ja virheiden syyt selvittää jälkikäteen.

  • --progress — tulostaa reaaliaikaisen yhteenvetorivin, joka näyttää käynnissä olevien, valmistuneiden ja jäljellä olevien töiden määrän.
  • --eta — arvioi valmistumiseen jäljellä olevan ajan tähänastisen työn keskimääräisen keston perusteella.
  • --joblog results.log — kirjoittaa sarkainerotellun lokitiedoston, jossa on yksi rivi jokaista valmistunutta työtä kohden. Rivi sisältää paluuarvon, suorituksen keston ja suoritetun komennon. Tämä on erittäin hyödyllinen virheiden tarkastuksessa.
  • --resume --joblog results.log — ohittaa työt, jotka ovat jo lokitiedostossa (ja joiden paluuarvo on 0). Jos eräajo keskeytyy, voitte jatkaa sitä suorittamatta onnistuneita töitä uudelleen.

Yhdistelmä --joblog + --resume on yksi GNU parallel -ohjelman tehokkaimmista ominaisuuksista luotettavia tuotantoputkia varten.

#!/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"

Tietotesti: työpaikkavalitsimet

Testatkaa ymmärrystänne siitä, miten parallel hallitsee samanaikaisuutta.

Vastaa interaktiivisessa oppitunnissa

Oppitunnin kertaus: työkuormien orkestrointi GNU parallel -ohjelmalla

Olette tutustuneet keskeisiin työkaluihin, joilla suuria syötejoukkoja jaetaan suorittimen ytimille GNU parallel -ohjelmalla. Tärkeimmät asiat ovat seuraavat:

  • Peruskäyttö: välittäkää luettelo komennolle parallel command {} — {} korvataan kullakin syötekohteella.
  • Työpaikat (-j): hallitkaa samanaikaisuutta tarkasti — käyttäkää ydinten määrää suorittimesta riippuvassa työssä ja suurempia prosenttiosuuksia I/O-riippuvaisessa työssä.
  • Paikanhaltijat ({.}, {/}, {//}, {/.}) poimivat polun osat siististi ilman ylimääräisiä komentoja.
  • Tulosteen hallinta: -k säilyttää syötteen järjestyksen; oletusarvoinen ryhmittely estää rivien lomittumisen; --ungroup mahdollistaa reaaliaikaisen suoratoiston.
  • Vikasietoisuus: --retries, --timeout ja --delay tekevät rinnakkaisista putkista kestäviä epävakaita töitä ja nopeusrajoituksia vastaan.
  • Auditointi: --joblog tallentaa jokaisen työn tuloksen; --resume avulla voitte jatkaa keskeytyksen jälkeen siitä, mihin jäitte.
  • Hajauttaminen: --sshloginfile jakaa työt etäkoneille SSH:n kautta ilman klusterin aiheuttamaa ylimääräistä hallintaa.

Näiden valitsinten hallinta muuttaa parallel-ohjelman tuotantotason työkuormien orkestroijaksi, joka on käytettävissä suoraan shellissä.

Aloita maksutta

Opi Bash tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit
22
Oppitunnit
88
Aloita opiskelu maksuttaNäytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Työkuormien orkestrointi GNU parallelilla” ilmainen?

Kyllä – oppitunnin ”Työkuormien orkestrointi GNU parallelilla” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Linux-komentorivin ja Bash-komentosarjojen hallinta-kurssin, päivitä CoddyKit PROhon. Linux-komentorivin ja Bash-komentosarjojen hallinta-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Työkuormien orkestrointi GNU parallelilla”?

Jaa suuret syötejoukot suorittimien kesken GNU parallelilla, työpaikoilla ja tulosten järjestyksen säilyttämisellä. Harjoittelet Linux-komentorivin ja Bash-komentosarjojen hallinta-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Linux-komentorivin ja Bash-komentosarjojen hallinta-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Linux-komentorivin ja Bash-komentosarjojen hallinta-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 3/4.

Kuinka kauan ”Työkuormien orkestrointi GNU parallelilla”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Linux-komentorivin ja Bash-komentosarjojen hallinta-oppitunnilla?

Kyllä. Jokainen Linux-komentorivin ja Bash-komentosarjojen hallinta-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

  1. Skriptien profilointi ja tarpeettomien alikuorien välttäminen
  2. Rinnakkaisuus xargs -P:llä ja taustatöillä
  3. Työkuormien orkestrointi GNU parallelilla
  4. Suoratoistoputket ja nimetyt putket läpimenon parantamiseen
← Takaisin: Linux-komentorivin ja Bash-komentosarjojen hallinta