delete: Variable $$ — récupérer le PID du shell

2026-05-16 18:03:53 +02:00
parent 6450edf6a8
commit aa6a415bb7
5 changed files with 0 additions and 196 deletions
@@ -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,37 +0,0 @@
 {
    "uuid": "b9f0369a-2823-4af4-819c-3a1fc0cf2b8c",
    "slug": "symbole-double-et-commercial-2",
    "title": "Variable `$$` — récupérer le PID du shell",
    "author": "cedric@abonnel.fr",
    "published": true,
    "featured": false,
    "published_at": "2023-01-09 22:35",
    "created_at": "2023-01-09 22:35:09",
    "updated_at": "2026-05-16 16:01:11",
    "revisions": [
        {
            "n": 1,
            "date": "2026-05-16 15:59:20",
            "comment": "Titre modifié, tags modifiés, contenu modifié, image de couverture modifiée",
            "title": "Paramètre && - retour du PID"
        },
        {
            "n": 2,
            "date": "2026-05-16 16:01:11",
            "comment": "Contenu modifié",
            "title": "Variable `$$` — récupérer le PID du shell"
        }
    ],
    "cover": "cover.png",
    "files_meta": [],
    "external_links": [],
    "seo_title": "",
    "seo_description": "",
    "og_image": "https://www.abonnel.fr/file?uuid=b9f0369a-2823-4af4-819c-3a1fc0cf2b8c&name=cover.png",
    "category": "Informatique",
    "tags": {
        "tags": [
            "Bash"
        ]
    }
 }
@@ -1,15 +0,0 @@
 # Paramètre && - retour du PID
 ![](logo_bash.png)
 Affiche le numéro de process de l’exécution de la ligne de commande en cours. Synonyme de PID, Process IDentification en cours.
 Dans un programme BASH, on peut récupérer le numéro du process de l'enfant avec la variable $BASHPID
 ```
 ~ $ echo $$
 17601
 ~ $ ( echo $$; echo $BASHPID )
 17601
 17634
 ```
@@ -1,22 +0,0 @@
 # Variable `$$` — récupérer le PID du shell
 La variable spéciale `$$` renvoie le **PID** (*Process IDentifier*) du shell courant. Elle est utile pour générer des noms de fichiers temporaires uniques, tracer un script dans les logs ou créer un fichier de verrou.
 ## Particularité dans les sous-shells
 `$$` conserve toujours la valeur du shell **parent**, même lorsqu'elle est évaluée dans un sous-shell `( … )`. Pour obtenir le PID réel du processus en cours d'exécution, Bash propose la variable `$BASHPID`.
 ```
 ~ $ 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.
 - `$BASHPID` affiche `17634` : c'est le PID du sous-shell créé par les parenthèses.
 Retenir la différence : **`$$` = PID du shell de référence**, **`$BASHPID` = PID du processus Bash réellement en cours**.