GNU Parallel : exécuter en parallèle

Quand vous devez traiter des centaines de fichiers, convertir des images en masse ou exécuter des scripts sur plusieurs serveurs, lancer les tâches une par une est trop lent. GNU Parallel permet d'exécuter plusieurs commandes simultanément, en exploitant tous les cœurs de votre CPU. Là où xargs traite séquentiellement, parallel répartit la charge et accélère drastiquement vos traitements batch.

Ce que vous allez apprendre

• Exécuter des commandes en parallèle avec :::
• Contrôler le nombre de jobs avec -j
• Utiliser les placeholders ({}, {.}, {/})
• Gérer les fichiers avec espaces et caractères spéciaux
• Surveiller la progression et gérer les erreurs
• Combiner parallel avec find et d'autres commandes

La commande parallel dans l'écosystème Linux

GNU Parallel est l'évolution logique de xargs pour les traitements en masse. Voici comment il se positionne :

Commande	Spécialité	Quand l'utiliser
parallel	Exécution parallèle	Traitement en masse, performance maximale
xargs	Exécution séquentielle	Commandes simples, une par une
make -j	Build parallèle	Compilation de projets
& / wait	Jobs background	Quelques tâches indépendantes

Glissez pour voir

Avantages de parallel sur xargs :

• Exécution réellement parallèle (pas juste -P)
• Barre de progression (--bar, --eta)
• Gestion des erreurs avancée (--halt)
• Placeholders riches ({.}, {/}, {#}...)
• Exécution sur serveurs distants (-S)

Comprendre GNU Parallel en 2 minutes

parallel lit une liste d'arguments, puis lance une instance de commande par argument, plusieurs à la fois. Il maintient en permanence le nombre de jobs demandé : dès qu'un job se termine, le suivant démarre, sans attendre que toute la vague soit finie. C'est ce mécanisme de file d'attente qui explique à la fois le gain de temps et les surprises sur l'ordre des sorties.

🧠 Modèle mental — Comment fonctionne parallel

parallel = Pour chaque argument → Lancer N commandes simultanément → Collecter les résultats

Points clés

• parallel lit les arguments et lance plusieurs instances de la commande simultanément
• Par défaut, parallel lance autant de jobs que de cœurs CPU
• {} représente l'argument courant, {.} sans extension, {/} nom de base
• ::: passe des arguments inline, :::: lit depuis un fichier
• L'ordre des sorties n'est PAS garanti (exécution parallèle)

Règles d'or

1

Toujours tester avec --dry-run d'abord Vérifie les commandes qui seront exécutées sans les lancer.

2

Limiter les jobs avec -j pour éviter la surcharge Trop de jobs parallèles peut saturer CPU, mémoire ou disque.

Vocabulaire essentiel

:::

Passe des arguments directement en ligne de commande

::::

Lit les arguments depuis un fichier

{}

Placeholder pour l'argument courant

-j N

Nombre de jobs en parallèle (défaut: nb CPU)

--dry-run

Affiche les commandes sans les exécuter

--bar

Affiche une barre de progression

📚 Pour aller plus loin — 12 options avancées

{.}

Argument sans extension

{/}

Nom de base (sans chemin)

{//}

Chemin du répertoire

{/.}

Nom de base sans extension

{#}

Numéro du job (séquence)

{%}

Numéro du slot (worker)

--colsep

Séparateur de colonnes pour plusieurs champs

--halt

Comportement sur erreur (now,fail=1...)

--results

Enregistre stdout/stderr dans un dossier

--eta

Affiche le temps restant estimé

--null

Arguments séparés par NUL (pour find -print0)

-S

Exécution sur serveurs distants (SSH)

Contrairement à xargs qui passe les arguments à une seule instance de commande, parallel lance N instances simultanées (N = nombre de cœurs CPU par défaut).

Syntaxe complète

Les options se placent avant la commande à exécuter, sinon parallel les transmet à cette commande. Trois formes existent selon la provenance des arguments, et elles ne se distinguent que par le séparateur : ::: en ligne, :::: depuis un fichier, ou rien du tout quand les arguments arrivent par un tube.

parallel [options] commande ::: arguments           # Arguments inline
parallel [options] commande :::: fichier.txt        # Arguments depuis fichier
cat liste.txt | parallel [options] commande {}      # Arguments depuis stdin

Options principales :

Option	Description	Exemple
-j N	N jobs en parallèle (défaut: nb CPU)	parallel -j 4 ...
--dry-run	Affiche sans exécuter	parallel --dry-run rm ...
--bar	Barre de progression	parallel --bar cmd ...
--halt	Comportement sur erreur	--halt now,fail=1
-k	Préserve l'ordre des sorties	parallel -k echo ...

Glissez pour voir

Les 3 parties d'une commande parallel

Toute ligne parallel se décompose de la même façon, ce qui aide à repérer d'où vient une erreur : un argument mal découpé vient de la source, une commande introuvable vient du deuxième bloc, une machine saturée vient du troisième.

Partie	Question	Exemples	Obligatoire ?
Source	D'où viennent les arguments ?	:::, ::::, stdin	Oui
Commande	Quelle commande exécuter ?	gzip {}, convert	Oui
Contrôle	Combien de parallélisme ?	-j 4, --bar	Non (défauts)

Glissez pour voir

Les placeholders : le cœur de parallel

Un placeholder indique où l'argument doit être inséré dans la commande. Si vous n'en mettez aucun, parallel ajoute automatiquement l'argument à la fin de la commande, ce qui explique que parallel gzip ::: *.log fonctionne sans {}. Les variantes ci-dessous découpent l'argument en chemin, nom et extension, sans appeler basename ni dirname.

Placeholder	Signification	Exemple (/path/photo.jpg)
{}	Argument complet	/path/photo.jpg
{.}	Sans extension	/path/photo
{/}	Nom de base (sans chemin)	photo.jpg
{//}	Chemin du répertoire	/path
{/.}	Nom de base sans extension	photo
{#}	Numéro du job (1, 2, 3...)	1
{%}	Numéro du slot (worker)	2

Glissez pour voir

Exemple de conversion :

# Convertir photo.jpg → photo.png
parallel convert {} {.}.png ::: *.jpg

# Résultat pour photo.jpg :
# convert photo.jpg photo.png

Les sources d'arguments

La source détermine le séparateur d'arguments : le retour à la ligne pour un fichier ou un tube, l'espace du shell pour la forme inline. C'est cette différence qui rend les noms de fichiers contenant des espaces dangereux avec certaines sources.

Source	Syntaxe	Exemple
Inline	::: arg1 arg2	parallel echo ::: a b c
Fichier	:::: fichier.txt	parallel wget :::: urls.txt
Stdin	cmd | parallel	find . | parallel gzip
Multi-colonnes	--colsep	parallel --colsep ',' cp {1} {2}

Glissez pour voir

Contrôler le parallélisme

Sans -j, parallel lance autant de jobs simultanés que la machine a de cœurs CPU. Ce défaut convient à un traitement gourmand en calcul, mais il est trop élevé pour des tâches limitées par le disque ou le réseau, et beaucoup trop faible pour des attentes réseau où plusieurs dizaines de jobs tiennent sans effort.

# Défaut : autant de jobs que de cœurs CPU
parallel gzip ::: *.log

# Limiter à 4 jobs simultanés
parallel -j 4 gzip ::: *.log

# Un seul job (séquentiel, pour debug)
parallel -j 1 gzip ::: *.log

# Autant de jobs que d'arguments (attention !)
parallel -j 0 gzip ::: *.log

Attention : trop de jobs parallèles peut saturer le système (CPU, mémoire, I/O disque). Commencez par -j 4 et ajustez.

Gestion des fichiers avec espaces

Le piège classique : les fichiers avec espaces sont mal découpés.

# INCORRECT : DANGER : "mon fichier.jpg" devient "mon" et "fichier.jpg"
ls *.jpg | parallel echo {}

# CORRECT : CORRECT : utiliser find -print0 + --null
find . -name "*.jpg" -print0 | parallel --null echo {}

La combinaison find -print0 | parallel --null est le pattern sécurisé pour tous les traitements de fichiers.

Erreurs typiques (et solutions)

Ces cinq situations couvrent la quasi-totalité des appels au support autour de parallel. Deux d'entre elles sont silencieuses : les fichiers mal découpés et les sorties désordonnées ne produisent aucun message d'erreur, seulement un résultat faux.

Erreur	Cause	Solution
Fichiers mal découpés	Espaces dans les noms	find -print0 | parallel --null
Sorties mélangées	Exécution parallèle	Ajouter -k ou --line-buffer
Système saturé	Trop de jobs	Limiter avec -j 4
Fichiers supprimés par erreur	Pas de test	TOUJOURS --dry-run d'abord
SSH demande mot de passe	Clé non configurée	ssh-copy-id user@serveur

Glissez pour voir

Installation

GNU Parallel n'est pas toujours installé par défaut :

# Debian/Ubuntu
sudo apt install parallel

# CentOS/RHEL/Fedora
sudo dnf install parallel

# macOS (Homebrew)
brew install parallel

# Vérification
parallel --version

Les modèles essentiels

Maintenant que vous comprenez la logique de parallel, voici dix modèles prêts à l'emploi. Chacun donne sa formule générale et un exemple concret.

Exécution parallèle basique

Lancer la même commande sur plusieurs arguments.

parallel commande ::: arg1 arg2 arg3   # formule
parallel gzip ::: *.log                # exemple

• ::: : sépare la commande de la liste d'arguments

Depuis l'entrée standard

Lire les arguments depuis un pipe.

cat liste.txt | parallel commande {}                 # formule
find . -name "*.jpg" | parallel convert {} {.}.png   # exemple

• {} : placeholder de l'argument courant

Limiter le parallélisme

Contrôler le nombre de jobs simultanés.

parallel -j N commande ::: arguments   # formule
parallel -j 4 gzip ::: *.log           # exemple

• -j N : N jobs maximum (défaut : nombre de cœurs CPU)
• -j 0 : autant de jobs que d'arguments

Mode simulation

Vérifier les commandes avant de les exécuter.

parallel --dry-run commande ::: arguments   # formule
parallel --dry-run rm ::: *.bak             # exemple

• --dry-run : affiche les commandes sans rien lancer, indispensable avant rm

Transformation de fichiers

Convertir des fichiers en changeant leur extension.

parallel commande {} {.}.new_ext ::: fichiers   # formule
parallel ffmpeg -i {} {.}.mp3 ::: *.wav         # exemple

• {.} : argument sans extension, {/} : nom de base, {//} : répertoire

Fichiers avec espaces (sécurisé)

Traiter sans risque les noms contenant des espaces.

find . -print0 | parallel --null commande {}                       # formule
find . -name "*.jpg" -print0 | parallel --null convert {} {.}.png  # exemple

• -print0 + --null : séparateur nul, le couple sûr pour les fichiers

Suivi de progression

Afficher l'avancement des tâches.

parallel --bar commande ::: arguments      # formule
parallel --bar --eta gzip ::: *.log        # exemple

• --bar : barre de progression, --eta : temps restant estimé

Gestion des erreurs

Contrôler le comportement quand une tâche échoue.

parallel --halt now,fail=1 commande ::: arguments      # formule
parallel --halt now,fail=1 ./script.sh ::: *.txt       # exemple

• now,fail=1 : stoppe dès la première erreur
• soon,fail=20% : stoppe au-delà de 20 % d'échecs

Arguments multi-colonnes

Utiliser plusieurs champs par ligne d'un fichier.

parallel --colsep ',' commande {1} {2} :::: fichier.csv    # formule
parallel --colsep ',' cp {1} {2} :::: batch.csv            # exemple

• --colsep : séparateur de colonnes, {1}, {2} : les colonnes
• :::: : lit les arguments depuis un fichier

Exécution sur serveurs distants

Distribuer les tâches sur plusieurs machines via SSH.

parallel -S serveur1,serveur2 commande ::: arguments    # formule
parallel -S srv1,srv2,srv3 hostname ::: {1..10}         # exemple

• -S : liste des serveurs SSH (clé SSH sans mot de passe requise)

Les pièges à éviter

Huit erreurs reviennent constamment avec parallel. Certaines sont destructrices, d'autres saturent simplement la machine.

Pas de test avant rm/mv

C'est le seul piège de cette liste qui soit irréversible : rm ne passe par aucune corbeille, et le glob est développé par le shell avant que parallel ne voie quoi que ce soit.

parallel rm ::: *.bak   # INCORRECT : supprime immédiatement, sans retour possible

Symptôme : des fichiers supprimés par erreur. Cause : aucune vérification des commandes avant exécution.

parallel --dry-run rm ::: *.bak   # CORRECT : prévisualiser, puis relancer sans --dry-run

Surcharge du système

Au-delà du nombre de cœurs, les jobs supplémentaires ne calculent pas plus vite : ils se disputent le CPU et la mémoire, et le temps total peut devenir supérieur à celui d'un traitement séquentiel.

parallel -j 100 gzip ::: *.log   # INCORRECT : trop de jobs : système saturé

Symptôme : système lent, mémoire saturée, swap intense. Cause : trop de processus parallèles pour les ressources disponibles.

parallel -j 4 gzip ::: *.log   # CORRECT : limiter à un nombre raisonnable

Fichiers avec espaces

Le piège est silencieux : la commande s'exécute, ne renvoie aucune erreur, et traite deux arguments inexistants au lieu du fichier réel.

ls *.jpg | parallel echo {}   # INCORRECT : casse sur "mon fichier.jpg"

Symptôme : les arguments sont coupés au niveau des espaces. Cause : le retour à la ligne est le séparateur par défaut.

find . -name "*.jpg" -print0 | parallel --null echo {}   # CORRECT : séparateur nul

Ordre des sorties non garanti

L'ordre d'affichage suit l'ordre de fin des jobs, pas leur ordre de lancement : un job court démarré en troisième s'affiche avant un job long démarré en premier.

parallel echo ::: 1 2 3 4 5   # INCORRECT : affichage dans un ordre aléatoire

Symptôme : résultats désordonnés. Cause : l'exécution parallèle ne garantit aucun ordre.

parallel -k echo ::: 1 2 3 4 5   # CORRECT : -k préserve l'ordre des sorties

Sorties entremêlées

Par défaut, parallel applique --group : la sortie de chaque job est conservée entière et affichée seulement quand le job se termine. Le mélange n'apparaît qu'avec -u (--ungroup), qui écrit au fil de l'eau et peut couper une ligne en deux.

parallel -u commande ::: args   # INCORRECT : une ligne peut être coupée en deux

Symptôme : lignes de sortie entrelacées, illisibles. Cause : -u court-circuite la mise en tampon interne de parallel.

parallel --line-buffer commande ::: args   # CORRECT : chaque ligne reste entière

SSH sans clé configurée

parallel n'a aucun terminal à offrir aux jobs distants : la demande de mot de passe n'apparaît jamais, le job reste simplement bloqué jusqu'au délai d'expiration SSH.

parallel -S serveur commande ::: args   # INCORRECT : bloque sur la demande de mot de passe

Symptôme : exécution figée, timeout. Cause : authentification SSH par clé non configurée.

ssh-copy-id user@serveur   # CORRECT : configurer la clé, puis relancer parallel

Guillemets mal gérés

Entre guillemets doubles, c'est le shell qui interprète la chaîne avant de la transmettre : les variables sont substituées et les caractères spéciaux développés au mauvais moment. Les guillemets simples transmettent le texte tel quel à parallel.

parallel echo "File: {}" ::: *.txt   # INCORRECT : le shell interprète les guillemets

Symptôme : arguments mal passés, caractères spéciaux interprétés. Cause : le shell traite les guillemets avant parallel.

parallel echo 'File: {}' ::: *.txt   # CORRECT : guillemets simples

Conflits d'écriture dans un fichier

L'ajout >> n'est atomique que pour de très petites écritures : au-delà de la taille d'un tampon système, deux jobs qui écrivent en même temps produisent des lignes tronquées et imbriquées, sans aucun message d'erreur.

parallel "cat {} >> output.txt" ::: *.log   # INCORRECT : fichier de sortie corrompu

Symptôme : sortie corrompue, lignes mélangées. Cause : plusieurs processus écrivent dans le même fichier en même temps.

parallel "cat {} > {}.out" ::: *.log && cat *.out > output.txt   # CORRECT : un fichier par job, puis fusion

Travaux pratiques

Rien ne remplace la pratique. Créez l'environnement de test ci-dessous, puis déroulez les huit étapes. À la fin, nettoyez avec rm -rf ~/parallel-lab.

Préparer le terrain

Ce script crée une arborescence dans ~/parallel-lab : des images (dont certaines avec des espaces dans le nom), des logs, une liste de serveurs, une liste d'URLs et un CSV.

# Créer le lab
mkdir -p ~/parallel-lab/{images,logs,data}
cd ~/parallel-lab

# Fichiers images simulés
for i in {1..10}; do
  echo "image $i data" > images/photo_$i.jpg
done

# Fichiers avec espaces dans le nom
echo "data 1" > "images/mon fichier 1.jpg"
echo "data 2" > "images/photo vacances 2024.jpg"

# Fichiers de logs
for i in {1..5}; do
  echo "Log content $i" > logs/app_$i.log
done

# Liste d'URLs
cat > urls.txt << 'EOF'
https://example.com/file1.txt
https://example.com/file2.txt
https://example.com/file3.txt
EOF

# Fichier CSV pour les tests multi-colonnes
cat > data/batch.csv << 'EOF'
fichier1,output1
fichier2,output2
fichier3,output3
EOF

echo "Correct : Lab créé dans ~/parallel-lab"
ls -la ~/parallel-lab/

Les huit étapes

Chaque étape isole une option à la fois et se déroule sur les fichiers créés ci-dessus. Aucune n'est destructrice : les seules suppressions passent par --dry-run.

1. Première commande parallèle. Exécutez echo sur plusieurs arguments avec :::.

   parallel echo ::: un deux trois quatre

   ::: passe les arguments à parallel ; chaque echo s'exécute en parallèle (l'ordre varie).

2. Utiliser le placeholder {}. Affichez « Traitement de … » pour chaque image.

   ls ~/parallel-lab/images/*.jpg | parallel echo "Traitement de {}"

   {} est remplacé par chaque ligne de l'entrée standard.

3. Tester sans exécuter. Vérifiez les suppressions qui seraient effectuées, sans rien supprimer.

   ls ~/parallel-lab/logs/*.log | parallel --dry-run rm {}

   --dry-run affiche les commandes sans les lancer, essentiel avant un rm.

4. Limiter le parallélisme. Lancez 6 sleep de 1 seconde, 2 à la fois.

   parallel -j 2 sleep 1 ::: {1..6}

   -j 2 limite à 2 jobs simultanés, l'ensemble prend environ 3 secondes.

5. Transformer des fichiers. Simulez la conversion des .jpg en .png.

   ls ~/parallel-lab/images/*.jpg | parallel --dry-run echo convert {} {.}.png

   {.} retire l'extension, idéal pour les conversions de format.

6. Gérer les fichiers avec espaces. Traitez les images, espaces compris.

   find ~/parallel-lab/images -name "*.jpg" -print0 | parallel --null echo "Fichier : {}"

   -print0 et --null préservent les noms contenant des espaces.

7. Afficher la progression. Lancez des tâches avec une barre de progression.

   parallel --bar sleep 0.5 ::: {1..10}

   --bar affiche la progression ; --eta ajoute le temps restant estimé.

8. Arrêt sur erreur. Faites stopper parallel dès la première erreur.

   parallel --halt now,fail=1 'test {} = 3 && exit 1; echo {}' ::: {1..5}

   --halt now,fail=1 arrête tout dès qu'un job renvoie un code d'erreur.

Exercices progressifs

Huit exercices pour valider votre maîtrise. Ils se traitent sur le lab ~/parallel-lab. Cherchez d'abord par vous-même, puis dépliez la solution pour vous corriger.

Niveau fondations

Exercice 1, Premiers pas avec :::. Affichez les nombres de 1 à 5 en parallèle. Indice : ::: passe les arguments à parallel.

Voir la solution

parallel echo ::: 1 2 3 4 5

::: sépare la commande des arguments ; chaque nombre est passé à echo.

Exercice 2, Compression parallèle. Compressez tous les fichiers .log du lab avec gzip. Indice : ::: avec le glob *.log.

Voir la solution

parallel gzip ::: ~/parallel-lab/logs/*.log

Chaque fichier .log est compressé simultanément.

Exercice 3, Mode simulation. Vérifiez les commandes qui supprimeraient les fichiers .bak, sans rien supprimer. Indice : --dry-run.

Voir la solution

parallel --dry-run rm ::: *.bak

--dry-run est indispensable avant toute commande destructive.

Niveau composition

Exercice 4, Limiter le parallélisme. Lancez 6 sleep de 1 seconde, mais 2 à la fois seulement. Indice : -j limite le nombre de jobs.

Voir la solution

time parallel -j 2 sleep 1 ::: {1..6}

-j 2 limite à 2 jobs simultanés : 6 jobs = 3 vagues de 2, soit ≈ 3 secondes.

Exercice 5, Conversion de fichiers. Simulez (avec echo) la conversion des images .jpg en .png. Indice : {.} donne le nom sans extension.

Voir la solution

ls ~/parallel-lab/images/*.jpg | parallel --dry-run convert {} {.}.png

{.} retire l'extension, parfait pour les conversions de format.

Niveau industrialisation

Exercice 6, Fichiers avec espaces. Listez tous les .jpg du lab de façon sûre, y compris ceux avec des espaces. Indice : find -print0 + parallel --null.

Voir la solution

find ~/parallel-lab/images -name "*.jpg" -print0 | parallel --null echo "Fichier : {}"

-print0 et --null gèrent les espaces et caractères spéciaux.

Exercice 7, Multi-colonnes CSV. À partir de batch.csv, simulez des copies source → destination. Indice : --colsep et {1}, {2}.

Voir la solution

parallel --colsep ',' --dry-run cp {1} {2} :::: ~/parallel-lab/data/batch.csv

--colsep définit le séparateur ; {1} et {2} référencent les colonnes.

Niveau sécurité

Exercice 8, Gestion des erreurs. Lancez des commandes avec arrêt à la première erreur. Indice : --halt now,fail=1.

Voir la solution

parallel --halt now,fail=1 'if [ {} = 3 ]; then exit 1; fi; echo {}' ::: {1..5}

--halt now,fail=1 arrête tout dès qu'un job renvoie un code d'erreur.

Dépannage

Quand parallel se comporte mal, isolez la cause avec ces quatre vérifications avant tout.

Méthodes de diagnostic

Les quatre commandes ci-dessous répondent chacune à une question différente : ce que parallel va exécuter, ce qu'il exécute vraiment, ce que la commande reçoit comme argument, et si le problème vient du parallélisme lui-même. Commencez toujours par -j 1 quand un traitement se comporte de façon aléatoire : si l'erreur disparaît, c'est une concurrence, pas un bug de commande.

# Voir les commandes sans les exécuter
parallel --dry-run commande ::: arguments

# Afficher chaque commande avant exécution
parallel --verbose commande ::: arguments

# Remplacer la commande par echo pour observer
parallel echo "Je ferais : cmd {}" ::: args

# Exécuter séquentiellement pour isoler un problème
parallel -j 1 commande ::: arguments

Erreurs fréquentes

Ces messages viennent de parallel lui-même ou de la commande qu'il lance, et le premier est le plus déroutant : parallel attend une entrée qui n'arrive jamais, il reste donc en attente sans rien exécuter.

Message d'erreur	Cause probable	Solution
Warning: Input is read from the terminal	Aucune entrée (ni ::: ni pipe)	Ajouter ::: avec des arguments, ou un pipe
command not found	Commande absente du PATH	Vérifier avec which, ou utiliser un chemin absolu
Permission denied	Script non exécutable, droits insuffisants	chmod +x sur le script, vérifier les droits
ssh: Connection timed out	Serveur injoignable ou pare-feu	Tester ssh serveur echo OK, vérifier le réseau

Glissez pour voir

Aide-mémoire parallel

Les trois tableaux suivants condensent ce que vous rouvrirez le plus souvent : les formes d'appel, les options et les placeholders. Le reste des options de parallel se consulte dans man parallel, qui est volumineux mais organisé par thème.

Syntaxe générale

Le choix de la forme dépend uniquement de la provenance des arguments ; le comportement de parallel est identique ensuite.

Forme	Rôle	Exemple
parallel commande ::: arg1 arg2	Arguments en ligne de commande	parallel gzip ::: *.log
cat liste | parallel commande {}	Arguments depuis stdin	find . | parallel echo {}
parallel commande :::: fichier.txt	Arguments depuis un fichier	parallel wget :::: urls.txt
parallel --colsep "," cmd {1} {2} :::: data.csv	Arguments multi-colonnes	parallel --colsep "," cp {1} {2} :::: batch.csv

Glissez pour voir

Options principales

Toutes se placent avant la commande. --dry-run et -j sont les deux à retenir en priorité : la première évite les dégâts, la seconde évite de bloquer la machine.

Option	Rôle	Exemple
-j N	N jobs en parallèle (défaut : nb CPU)	parallel -j 4 gzip ::: *.log
--dry-run	Affiche sans exécuter	parallel --dry-run rm ::: *.bak
--verbose	Affiche chaque commande	parallel --verbose cmd ::: args
-k (--keep-order)	Préserve l'ordre des sorties	parallel -k echo ::: 1 2 3
--bar	Barre de progression	parallel --bar cmd ::: {1..100}
--eta	Temps restant estimé	parallel --eta cmd ::: args
--halt now,fail=1	Stoppe à la première erreur	parallel --halt now,fail=1 cmd ::: args
--null	Entrées séparées par un caractère nul	find -print0 | parallel --null cmd

Glissez pour voir

Placeholders

Ils se combinent librement dans une même commande, et peuvent apparaître plusieurs fois. Rappel utile : {1} et {2} ne servent qu'avec --colsep ou plusieurs sources d'arguments.

Placeholder	Rôle	Exemple
{}	Argument complet	echo {}
{.}	Sans extension	convert {} {.}.png
{/}	Nom de base (sans chemin)	echo {/}
{//}	Chemin du répertoire	mkdir -p {//}/out
{/.}	Nom de base sans extension	echo {/.}
{#}	Numéro du job	echo "Job {#} : {}"
{1}, {2}	Colonnes (avec --colsep)	cp {1} {2}

Glissez pour voir

Checklist de maîtrise

Vous maîtrisez parallel lorsque vous pouvez cocher chacun de ces points :

• Je sais utiliser ::: pour passer des arguments
• Je sais tester avec --dry-run avant d'exécuter
• Je sais limiter les jobs avec -j
• Je sais utiliser {} et {.} pour les placeholders
• Je sais gérer les fichiers avec espaces grâce à --null
• Je sais traiter un fichier CSV multi-colonnes avec --colsep
• Je sais gérer les erreurs avec --halt
• Je sais afficher la progression avec --bar et --eta

Cas d'usage avancés

Ces quatre scénarios illustrent la règle de dimensionnement la plus utile en pratique : le bon nombre de jobs dépend de la ressource saturée, pas du nombre de fichiers. Un encodage vidéo sature le CPU et supporte deux jobs ; un téléchargement attend le réseau et en supporte bien davantage.

Conversion de fichiers en masse

Les traitements multimédia consomment plusieurs cœurs par job : au-delà de deux jobs simultanés, le temps total cesse de baisser.

# Convertir toutes les images en parallèle
find . -name "*.jpg" -print0 | parallel --null --bar convert {} {.}.png

# Compresser des vidéos (limiter à 2 jobs car gourmand)
parallel -j 2 --eta ffmpeg -i {} -c:v libx264 {.}.mp4 ::: *.avi

Téléchargements parallèles

--limit-rate s'applique par job, pas globalement : avec -j 4, le débit total atteint quatre fois la valeur indiquée.

# Télécharger une liste d'URLs
parallel --bar wget :::: urls.txt

# Avec limite de bande passante par job
parallel -j 4 wget --limit-rate=1M {} :::: urls.txt

Exécution sur serveurs distants

Avec -S, parallel répartit les jobs entre les machines listées et applique la limite -j à chaque serveur, pas à l'ensemble.

# Lancer une commande sur plusieurs serveurs
parallel -S srv1,srv2,srv3 hostname

# Copier un fichier vers tous les serveurs
parallel -S srv1,srv2,srv3 --transferfile {} echo "Copié: {}" ::: config.yml

Prérequis : SSH sans mot de passe configuré (ssh-copy-id).

Traitement de fichiers CSV

--colsep attend une expression régulière, pas un simple caractère : un séparateur comme | doit donc être échappé. Cette forme ne gère pas les champs entourés de guillemets contenant eux-mêmes le séparateur.

# Fichier batch.csv : source,destination
# fichier1.txt,/backup/fichier1.txt
# fichier2.txt,/backup/fichier2.txt

parallel --colsep ',' cp {1} {2} :::: batch.csv

parallel vs xargs : quand choisir lequel ?

Le critère décisif n'est pas la vitesse mais la disponibilité : xargs fait partie des coreutils et se trouve sur toute machine, parallel s'installe. Sur un serveur que vous ne maîtrisez pas, ou dans un script destiné à tourner partout, xargs -P reste le choix raisonnable malgré ses limites.

Critère	parallel	xargs
Parallélisme natif	Oui, Optimisé	Attention : Limité (-P)
Barre de progression	Oui (--bar, --eta)	Non
Gestion des erreurs	Oui, --halt	Non, Basique
Placeholders	Oui, {}, {.}, {/}, {#}	Attention : {} seulement
Serveurs distants	Oui, -S	Non
Disponibilité	Attention : À installer	Oui, Préinstallé
Complexité	Attention : Plus d'options	Oui, Plus simple

Glissez pour voir

En résumé :

• xargs pour les cas simples où la commande est préinstallée
• parallel dès que vous avez besoin de performance, progression ou robustesse

Contrôle de connaissances

Vérifiez que l'essentiel de ce guide est acquis. Les questions portent uniquement sur ce qui vient d'être expliqué ici.

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

6 questions

6 min.

70% requis

Informations

• Le chronomètre démarre au clic sur Démarrer
• Questions à choix multiples, vrai/faux et réponses courtes
• Vous pouvez naviguer entre les questions
• Les résultats détaillés sont affichés à la fin

Démarrer le quiz

Lance le quiz et démarre le chronomètre

À retenir

1. ::: passe des arguments inline, :::: lit depuis un fichier
2. {} = argument complet, {.} = sans extension, {/} = nom de base
3. -j N limite le parallélisme, ne pas saturer le système
4. --dry-run est OBLIGATOIRE avant toute commande destructive (rm, mv)
5. find -print0 | parallel --null = pattern sécurisé pour les fichiers
6. --bar et --eta pour surveiller la progression
7. --halt now,fail=1 pour stopper à la première erreur
8. -k préserve l'ordre des sorties si important

×

📖 Voir la documentation →