publish: Variable $$ — récupérer le PID du shell
This commit is contained in:
Cédrix
@@ -1,15 +0,0 @@
|
||||
{
|
||||
"title": "Variable `$$` — récupérer le PID du shell",
|
||||
"_updated_at": "2026-05-16 16:04:25",
|
||||
"slug": "double-dollar",
|
||||
"published": true,
|
||||
"published_at": "2023-02-18 16:32",
|
||||
"category": "Informatique",
|
||||
"tags": {
|
||||
"tags": [
|
||||
"Bash"
|
||||
]
|
||||
},
|
||||
"seo_title": "",
|
||||
"seo_description": ""
|
||||
}
|
||||
@@ -1,122 +0,0 @@
|
||||
# Variable `$$` — récupérer le PID du shell
|
||||
|
||||
La variable spéciale `$$` renvoie le **PID** (*Process IDentifier*) du shell courant, c'est-à-dire le numéro unique qu'attribue le système d'exploitation à chaque processus en cours d'exécution. Cette variable est particulièrement utile dans plusieurs situations courantes que nous allons détailler ci-dessous.
|
||||
|
||||
## À quoi sert concrètement `$$` ?
|
||||
|
||||
### 1. Générer des noms de fichiers temporaires uniques
|
||||
|
||||
Quand un script crée un fichier temporaire, il faut éviter les collisions si plusieurs instances du script tournent en même temps. Utiliser `$$` dans le nom garantit l'unicité :
|
||||
|
||||
```bash
|
||||
#!/bin/bash
|
||||
# Création d'un fichier temporaire propre à cette exécution
|
||||
TMPFILE="/tmp/monscript.$$.tmp"
|
||||
echo "Données de travail" > "$TMPFILE"
|
||||
echo "Fichier temporaire créé : $TMPFILE"
|
||||
# Affichera par exemple : /tmp/monscript.17601.tmp
|
||||
```
|
||||
|
||||
Si deux utilisateurs lancent le script simultanément, l'un aura `/tmp/monscript.17601.tmp` et l'autre `/tmp/monscript.18422.tmp` — pas de conflit possible.
|
||||
|
||||
### 2. Tracer un script dans les logs
|
||||
|
||||
Lorsqu'un script écrit dans un journal commun, préfixer chaque ligne par le PID permet de distinguer les exécutions parallèles :
|
||||
|
||||
```bash
|
||||
#!/bin/bash
|
||||
echo "[$$] Démarrage du script à $(date)" >> /var/log/monscript.log
|
||||
echo "[$$] Traitement en cours..." >> /var/log/monscript.log
|
||||
echo "[$$] Fin du script" >> /var/log/monscript.log
|
||||
```
|
||||
|
||||
Résultat dans le log :
|
||||
```
|
||||
[17601] Démarrage du script à Sat May 16 14:23:01 CEST 2026
|
||||
[17601] Traitement en cours...
|
||||
[17601] Fin du script
|
||||
```
|
||||
|
||||
On peut ensuite filtrer une exécution particulière avec `grep "\[17601\]" /var/log/monscript.log`.
|
||||
|
||||
### 3. Créer un fichier de verrou (*lock file*)
|
||||
|
||||
Pour empêcher deux instances d'un script de tourner en même temps, on écrit son PID dans un fichier de verrou :
|
||||
|
||||
```bash
|
||||
#!/bin/bash
|
||||
LOCKFILE="/tmp/monscript.lock"
|
||||
|
||||
if [ -e "$LOCKFILE" ]; then
|
||||
echo "Script déjà en cours (PID $(cat $LOCKFILE)). Abandon."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo $$ > "$LOCKFILE" # On enregistre notre PID
|
||||
trap "rm -f $LOCKFILE" EXIT # On nettoie à la sortie
|
||||
|
||||
echo "Travail en cours sous le PID $$..."
|
||||
sleep 30
|
||||
```
|
||||
|
||||
## Particularité dans les sous-shells
|
||||
|
||||
`$$` conserve **toujours** la valeur du shell **parent**, même lorsqu'elle est évaluée dans un sous-shell `( … )`. C'est un piège classique : on pourrait croire que le sous-shell, étant un nouveau processus, aurait son propre PID via `$$` — ce n'est pas le cas.
|
||||
|
||||
Pour obtenir le PID réel du processus Bash en cours d'exécution, Bash propose la variable `$BASHPID`.
|
||||
|
||||
### Exemple comparatif
|
||||
|
||||
```bash
|
||||
~ $ echo $$
|
||||
17601
|
||||
~ $ ( echo $$; echo $BASHPID )
|
||||
17601
|
||||
17634
|
||||
```
|
||||
|
||||
Dans l'exemple ci-dessus :
|
||||
- `$$` affiche `17601` dans les deux cas : c'est le PID du shell interactif d'origine, conservé même à l'intérieur des parenthèses.
|
||||
- `$BASHPID` affiche `17634` : c'est le PID du sous-shell réellement créé par les parenthèses.
|
||||
|
||||
### Exemple plus parlant avec plusieurs niveaux de sous-shells
|
||||
|
||||
```bash
|
||||
~ $ echo "Shell principal : \$\$=$$ \$BASHPID=$BASHPID"
|
||||
Shell principal : $$=17601 $BASHPID=17601
|
||||
|
||||
~ $ ( echo "Sous-shell 1 : \$\$=$$ \$BASHPID=$BASHPID"
|
||||
( echo "Sous-shell 2 (imbriqué) : \$\$=$$ \$BASHPID=$BASHPID" )
|
||||
)
|
||||
Sous-shell 1 : $$=17601 $BASHPID=17634
|
||||
Sous-shell 2 (imbriqué) : $$=17601 $BASHPID=17699
|
||||
```
|
||||
|
||||
On voit clairement que :
|
||||
- `$$` reste figé à `17601` (le shell de départ) dans tous les contextes.
|
||||
- `$BASHPID` change à chaque niveau d'imbrication : `17634` pour le premier sous-shell, `17699` pour le second.
|
||||
|
||||
### Cas pratique : pourquoi cette distinction est importante
|
||||
|
||||
Imaginons qu'on veuille créer un fichier temporaire propre à un sous-shell :
|
||||
|
||||
```bash
|
||||
~ $ ( TMP="/tmp/sub.$$.txt"
|
||||
echo "fichier = $TMP"
|
||||
TMP_REAL="/tmp/sub.$BASHPID.txt"
|
||||
echo "fichier réel = $TMP_REAL"
|
||||
)
|
||||
fichier = /tmp/sub.17601.txt # ⚠️ même nom que le shell parent !
|
||||
fichier réel = /tmp/sub.17634.txt # ✅ vraiment unique au sous-shell
|
||||
```
|
||||
|
||||
Si plusieurs sous-shells utilisent `$$`, ils écrivent tous dans le même fichier — ce qui peut provoquer des écrasements de données. Avec `$BASHPID`, chaque sous-shell a son propre fichier.
|
||||
|
||||
## À retenir
|
||||
|
||||
| Variable | Valeur retournée |
|
||||
|-------------|-----------------------------------------------------|
|
||||
| `$$` | PID du shell **de référence** (le shell d'origine) |
|
||||
| `$BASHPID` | PID du processus Bash **réellement en cours** |
|
||||
|
||||
Dans un shell standard sans sous-shell, les deux valeurs sont identiques. La différence n'apparaît qu'à l'intérieur de `( … )`, et c'est précisément là qu'il faut savoir laquelle utiliser selon l'effet recherché.
|
||||
@@ -1,46 +1,122 @@
|
||||
# $$
|
||||
# Variable `$$` — récupérer le PID du shell
|
||||
|
||||
|
||||
La variable spéciale `$$` renvoie le **PID** (*Process IDentifier*) du shell courant, c'est-à-dire le numéro unique qu'attribue le système d'exploitation à chaque processus en cours d'exécution. Cette variable est particulièrement utile dans plusieurs situations courantes que nous allons détailler ci-dessous.
|
||||
|
||||
En Bash, `$$` est une variable qui contient le PID (Process ID) du processus en cours d'exécution. Cette variable peut être utilisée pour identifier de manière unique un processus ou pour contrôler les processus enfants créés à partir du script.
|
||||
## À quoi sert concrètement `$$` ?
|
||||
|
||||
Par exemple, vous pouvez utiliser `$$` pour créer un fichier journal unique pour chaque instance de votre script Bash en utilisant le PID comme partie du nom du fichier.
|
||||
### 1. Générer des noms de fichiers temporaires uniques
|
||||
|
||||
Notez cependant que le PID est une valeur dynamique qui change chaque fois que le processus est exécuté, donc `$$` ne doit être utilisé que dans le contexte du processus en cours d'exécution.
|
||||
Quand un script crée un fichier temporaire, il faut éviter les collisions si plusieurs instances du script tournent en même temps. Utiliser `$$` dans le nom garantit l'unicité :
|
||||
|
||||
Pour utiliser "$$" correctement dans le contexte du processus en cours d'exécution, vous pouvez le stocker dans une variable dès le début de votre script Bash. De cette façon, la variable contiendra le PID du processus en cours d'exécution tout au long du script, même si le PID change pendant l'exécution du script.
|
||||
|
||||
Voici un exemple de code Bash montrant comment stocker "$$" dans une variable :
|
||||
```BASH
|
||||
```bash
|
||||
#!/bin/bash
|
||||
|
||||
# stocker le PID dans une variable
|
||||
current_pid=$$
|
||||
|
||||
# afficher le PID
|
||||
echo "Le PID du processus en cours d'exécution est : $current_pid"
|
||||
|
||||
# faire quelque chose d'autre dans le script...
|
||||
# Création d'un fichier temporaire propre à cette exécution
|
||||
TMPFILE="/tmp/monscript.$$.tmp"
|
||||
echo "Données de travail" > "$TMPFILE"
|
||||
echo "Fichier temporaire créé : $TMPFILE"
|
||||
# Affichera par exemple : /tmp/monscript.17601.tmp
|
||||
```
|
||||
|
||||
Ensuite, vous pouvez utiliser la variable `current_pid` tout au long de votre script pour référencer le PID du processus en cours d'exécution.
|
||||
Si deux utilisateurs lancent le script simultanément, l'un aura `/tmp/monscript.17601.tmp` et l'autre `/tmp/monscript.18422.tmp` — pas de conflit possible.
|
||||
|
||||
Notez que si votre script crée des processus enfants, le PID de ces processus enfants sera différent du PID du processus parent. Dans ce cas, vous pouvez utiliser `$$` pour référencer le PID du processus parent, et utiliser un autre mécanisme pour référencer le PID des processus enfants, comme par exemple en stockant le PID de chaque processus enfant dans un tableau ou un fichier.
|
||||
### 2. Tracer un script dans les logs
|
||||
|
||||
Pour connaître le PID du processus parent dans un script Bash, vous pouvez utiliser la variable spéciale `$PPID`. Cette variable contient le PID du processus parent qui a créé le processus en cours d'exécution.
|
||||
Lorsqu'un script écrit dans un journal commun, préfixer chaque ligne par le PID permet de distinguer les exécutions parallèles :
|
||||
|
||||
Voici un exemple de code Bash qui utilise `$PPID` pour afficher le PID du processus parent :
|
||||
|
||||
```BASH
|
||||
```bash
|
||||
#!/bin/bash
|
||||
|
||||
# stocker le PID du processus parent dans une variable
|
||||
parent_pid=$PPID
|
||||
|
||||
# afficher le PID du processus parent
|
||||
echo "Le PID du processus parent est : $parent_pid"
|
||||
|
||||
# faire quelque chose d'autre dans le script...
|
||||
echo "[$$] Démarrage du script à $(date)" >> /var/log/monscript.log
|
||||
echo "[$$] Traitement en cours..." >> /var/log/monscript.log
|
||||
echo "[$$] Fin du script" >> /var/log/monscript.log
|
||||
```
|
||||
|
||||
Notez que `$PPID` ne fonctionne que si le processus en cours d'exécution a été créé par un processus parent dans le même système d'exploitation. Si le processus en cours d'exécution a été créé par un autre système d'exploitation ou un autre type de processus, `$PPID` ne sera pas défini ou aura une valeur incorrecte.
|
||||
Résultat dans le log :
|
||||
```
|
||||
[17601] Démarrage du script à Sat May 16 14:23:01 CEST 2026
|
||||
[17601] Traitement en cours...
|
||||
[17601] Fin du script
|
||||
```
|
||||
|
||||
On peut ensuite filtrer une exécution particulière avec `grep "\[17601\]" /var/log/monscript.log`.
|
||||
|
||||
### 3. Créer un fichier de verrou (*lock file*)
|
||||
|
||||
Pour empêcher deux instances d'un script de tourner en même temps, on écrit son PID dans un fichier de verrou :
|
||||
|
||||
```bash
|
||||
#!/bin/bash
|
||||
LOCKFILE="/tmp/monscript.lock"
|
||||
|
||||
if [ -e "$LOCKFILE" ]; then
|
||||
echo "Script déjà en cours (PID $(cat $LOCKFILE)). Abandon."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo $$ > "$LOCKFILE" # On enregistre notre PID
|
||||
trap "rm -f $LOCKFILE" EXIT # On nettoie à la sortie
|
||||
|
||||
echo "Travail en cours sous le PID $$..."
|
||||
sleep 30
|
||||
```
|
||||
|
||||
## Particularité dans les sous-shells
|
||||
|
||||
`$$` conserve **toujours** la valeur du shell **parent**, même lorsqu'elle est évaluée dans un sous-shell `( … )`. C'est un piège classique : on pourrait croire que le sous-shell, étant un nouveau processus, aurait son propre PID via `$$` — ce n'est pas le cas.
|
||||
|
||||
Pour obtenir le PID réel du processus Bash en cours d'exécution, Bash propose la variable `$BASHPID`.
|
||||
|
||||
### Exemple comparatif
|
||||
|
||||
```bash
|
||||
~ $ echo $$
|
||||
17601
|
||||
~ $ ( echo $$; echo $BASHPID )
|
||||
17601
|
||||
17634
|
||||
```
|
||||
|
||||
Dans l'exemple ci-dessus :
|
||||
- `$$` affiche `17601` dans les deux cas : c'est le PID du shell interactif d'origine, conservé même à l'intérieur des parenthèses.
|
||||
- `$BASHPID` affiche `17634` : c'est le PID du sous-shell réellement créé par les parenthèses.
|
||||
|
||||
### Exemple plus parlant avec plusieurs niveaux de sous-shells
|
||||
|
||||
```bash
|
||||
~ $ echo "Shell principal : \$\$=$$ \$BASHPID=$BASHPID"
|
||||
Shell principal : $$=17601 $BASHPID=17601
|
||||
|
||||
~ $ ( echo "Sous-shell 1 : \$\$=$$ \$BASHPID=$BASHPID"
|
||||
( echo "Sous-shell 2 (imbriqué) : \$\$=$$ \$BASHPID=$BASHPID" )
|
||||
)
|
||||
Sous-shell 1 : $$=17601 $BASHPID=17634
|
||||
Sous-shell 2 (imbriqué) : $$=17601 $BASHPID=17699
|
||||
```
|
||||
|
||||
On voit clairement que :
|
||||
- `$$` reste figé à `17601` (le shell de départ) dans tous les contextes.
|
||||
- `$BASHPID` change à chaque niveau d'imbrication : `17634` pour le premier sous-shell, `17699` pour le second.
|
||||
|
||||
### Cas pratique : pourquoi cette distinction est importante
|
||||
|
||||
Imaginons qu'on veuille créer un fichier temporaire propre à un sous-shell :
|
||||
|
||||
```bash
|
||||
~ $ ( TMP="/tmp/sub.$$.txt"
|
||||
echo "fichier = $TMP"
|
||||
TMP_REAL="/tmp/sub.$BASHPID.txt"
|
||||
echo "fichier réel = $TMP_REAL"
|
||||
)
|
||||
fichier = /tmp/sub.17601.txt # ⚠️ même nom que le shell parent !
|
||||
fichier réel = /tmp/sub.17634.txt # ✅ vraiment unique au sous-shell
|
||||
```
|
||||
|
||||
Si plusieurs sous-shells utilisent `$$`, ils écrivent tous dans le même fichier — ce qui peut provoquer des écrasements de données. Avec `$BASHPID`, chaque sous-shell a son propre fichier.
|
||||
|
||||
## À retenir
|
||||
|
||||
| Variable | Valeur retournée |
|
||||
|-------------|-----------------------------------------------------|
|
||||
| `$$` | PID du shell **de référence** (le shell d'origine) |
|
||||
| `$BASHPID` | PID du processus Bash **réellement en cours** |
|
||||
|
||||
Dans un shell standard sans sous-shell, les deux valeurs sont identiques. La différence n'apparaît qu'à l'intérieur de `( … )`, et c'est précisément là qu'il faut savoir laquelle utiliser selon l'effet recherché.
|
||||
@@ -1,18 +1,31 @@
|
||||
{
|
||||
"uuid": "97a8f127-ee98-4b55-b565-5ff148fb8178",
|
||||
"slug": "double-dollar",
|
||||
"title": "$$",
|
||||
"title": "Variable `$$` — récupérer le PID du shell",
|
||||
"author": "cedric@abonnel.fr",
|
||||
"published": true,
|
||||
"published_at": "2023-02-18 16:32:17",
|
||||
"featured": false,
|
||||
"published_at": "2023-02-18 16:32",
|
||||
"created_at": "2023-02-18 16:32:17",
|
||||
"updated_at": "2023-02-18 16:32:17",
|
||||
"revisions": [],
|
||||
"updated_at": "2026-05-16 16:04:26",
|
||||
"revisions": [
|
||||
{
|
||||
"n": 1,
|
||||
"date": "2026-05-16 16:04:26",
|
||||
"comment": "Titre modifié, tags modifiés, contenu modifié",
|
||||
"title": "$$"
|
||||
}
|
||||
],
|
||||
"cover": "",
|
||||
"files_meta": [],
|
||||
"external_links": [],
|
||||
"seo_title": "",
|
||||
"seo_description": "",
|
||||
"og_image": "",
|
||||
"category": "Informatique"
|
||||
"category": "Informatique",
|
||||
"tags": {
|
||||
"tags": [
|
||||
"Bash"
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,46 @@
|
||||
# $$
|
||||
|
||||
|
||||
|
||||
En Bash, `$$` est une variable qui contient le PID (Process ID) du processus en cours d'exécution. Cette variable peut être utilisée pour identifier de manière unique un processus ou pour contrôler les processus enfants créés à partir du script.
|
||||
|
||||
Par exemple, vous pouvez utiliser `$$` pour créer un fichier journal unique pour chaque instance de votre script Bash en utilisant le PID comme partie du nom du fichier.
|
||||
|
||||
Notez cependant que le PID est une valeur dynamique qui change chaque fois que le processus est exécuté, donc `$$` ne doit être utilisé que dans le contexte du processus en cours d'exécution.
|
||||
|
||||
Pour utiliser "$$" correctement dans le contexte du processus en cours d'exécution, vous pouvez le stocker dans une variable dès le début de votre script Bash. De cette façon, la variable contiendra le PID du processus en cours d'exécution tout au long du script, même si le PID change pendant l'exécution du script.
|
||||
|
||||
Voici un exemple de code Bash montrant comment stocker "$$" dans une variable :
|
||||
```BASH
|
||||
#!/bin/bash
|
||||
|
||||
# stocker le PID dans une variable
|
||||
current_pid=$$
|
||||
|
||||
# afficher le PID
|
||||
echo "Le PID du processus en cours d'exécution est : $current_pid"
|
||||
|
||||
# faire quelque chose d'autre dans le script...
|
||||
```
|
||||
|
||||
Ensuite, vous pouvez utiliser la variable `current_pid` tout au long de votre script pour référencer le PID du processus en cours d'exécution.
|
||||
|
||||
Notez que si votre script crée des processus enfants, le PID de ces processus enfants sera différent du PID du processus parent. Dans ce cas, vous pouvez utiliser `$$` pour référencer le PID du processus parent, et utiliser un autre mécanisme pour référencer le PID des processus enfants, comme par exemple en stockant le PID de chaque processus enfant dans un tableau ou un fichier.
|
||||
|
||||
Pour connaître le PID du processus parent dans un script Bash, vous pouvez utiliser la variable spéciale `$PPID`. Cette variable contient le PID du processus parent qui a créé le processus en cours d'exécution.
|
||||
|
||||
Voici un exemple de code Bash qui utilise `$PPID` pour afficher le PID du processus parent :
|
||||
|
||||
```BASH
|
||||
#!/bin/bash
|
||||
|
||||
# stocker le PID du processus parent dans une variable
|
||||
parent_pid=$PPID
|
||||
|
||||
# afficher le PID du processus parent
|
||||
echo "Le PID du processus parent est : $parent_pid"
|
||||
|
||||
# faire quelque chose d'autre dans le script...
|
||||
```
|
||||
|
||||
Notez que `$PPID` ne fonctionne que si le processus en cours d'exécution a été créé par un processus parent dans le même système d'exploitation. Si le processus en cours d'exécution a été créé par un autre système d'exploitation ou un autre type de processus, `$PPID` ne sera pas défini ou aura une valeur incorrecte.
|
||||
Reference in New Issue
Block a user