Comment vérifier si un id de processus (PID) existe

Dans un script bash, je veux faire la chose suivante (en pseudo-code):

if [ a process exists with $PID ]; then

    kill $PID 

fi

Ce qui est l'expression appropriée pour l'instruction conditionnelle?

InformationsquelleAutor Richard H | 2010-06-15

165

Pour vérifier l'existence d'un processus, utilisez
```
kill -0 $pid
```
Mais tout comme @détendez-vous dit, si vous allez le tuer de toute façon, juste
```
kill $pid
```
ou vous aurez une condition de course.

Si vous souhaitez ignorer le texte de sortie de kill et faire quelque chose de basé sur le code de sortie, vous pouvez
```
if ! kill $pid > /dev/null 2>&1; then
    echo "Could not send SIGTERM to process $pid" >&2
fi
```
- en regardant la page de man, tuer -0 est: "code de sortie indique si un signal peut être envoyé". Donc effectivement tuer un processus, ou tout simplement de vous dire s'il peut être tué?
- kill est un peu mal nommée, en ce qu'elle n'est pas nécessairement tuer le processus. Il envoie le processus d'un signal. kill $PID est équivalent à kill -15 $PID, qui envoie le signal 15, SIGTERM au processus, ce qui est une instruction de mettre fin. Il n'y a pas un signal de 0, c'est une valeur particulière de raconter kill de simplement vérifier si un signal peut être envoyé dans le processus, ce qui est pour la plupart des fins plus ou moins équivalent à vérifier s'il existe. Voir linux.die.net/man/2/kill et linux.die.net/man/7/signal
- C'est le problème que si le processus n'est pas détenu par l'utilisateur en cours d'exécution, vous ne disposez pas des autorisations pour appeler tuer -0. Mieux utiliser le ps -p $PID > /dev/null 2>,&1 qui vous permet de voir l'état du processus, même si vous ne disposez pas des autorisations pour envoyer un signal.
- Dans ce cas, il ne peut pas le tuer de toute façon.
- Donc, je suppose - pour utiliser kill -0, j'ai, en fait, ont pour ce faire: kill -0 25667 ; echo $? - et puis, si je reçois un 0 retournés, les processus avec qui PID peut être tué; et si le processus de PID (dire) n'existe pas, le $? sera 1, indiquant un échec. Est-ce exact?
- Lire de nouveau. Si vous allez le tuer de toute façon, puis juste le tuer, sinon vous aurez une condition de course. Mais oui, un code de sortie de 0 signifie qu'il est possible d'envoyer un signal à l'époque. Cela ne signifie pas que vous pouvez être sûr que vous pouvez envoyer un signal à un millième de seconde plus tard.
- Si pour une raison quelconque $PID est 0 (par exemple, il était censé être lu à partir d'un fichier pid, mais le fichier est manquant et un peu de logique décide de mettre un "0" à la place), puis de les tuer -0 0 retourne le code d'erreur 0, comme si le processus de pid existe! Méfiez-vous de ce piège.
InformationsquelleAutor Christoffer Hammarström
232

La meilleure façon est:
```
if ps -p $PID > /dev/null
then
   echo "$PID is running"
   # Do something knowing the pid exists, i.e. the process with $PID is running
fi
```
Le problème avec:
```
kill -0 $PID
```
est le code de sortie sera non nulle même si le pid est en cours d'exécution et vous n'avez pas la permission de le tuer. Par exemple:
```
kill -0 1
```
et
```
kill -0 $non-running-pid
```
ont une indiscernables (non-nulle) code de sortie pour un utilisateur normal, mais le processus init (PID 1) est certainement en cours d'exécution.

DISCUSSION

Les réponses à discuter de tuer et de conditions de course sont exactement si le corps de l'essai est de "tuer". Je suis venu à la recherche pour le général "comment faites-vous tester pour un PID existence dans bash".

/Proc méthode est intéressante, mais dans un certain sens, les sauts de l'esprit de la "ps" de la commande de l'abstraction, c'est à dire que vous n'avez pas besoin d'aller chercher dans /proc parce que si Linus décide d'appeler le "exe" quelque chose d'autre?
- ps -p renvoie toujours le statut de 0 pour moi
- Ps -p astuce ne fonctionne pas dans mon ubuntu.
- ps -p #### a bien fonctionné pour moi sous Ubuntu 14.04, +1 merci!
- ps -p toujours renvoie le code d'état 0 dans os x, car il imprime une liste vide de processus lorsqu'il ne correspond à n'importe quel processus en cours d'exécution
- Je peux confirmer que sur macOS Sierra, cela fonctionne. Aussi, le -p est inutile, au moins dans ce cas. ps $PID a exactement le même résultat.
- La portabilité est une bonne raison pour éviter l'utilisation de /proc, mais linux de briser son ABI n'est pas un scénario, je voudrais tout particulièrement s'inquiéter.
InformationsquelleAutor FDS
60
```
if [ -n "$PID" -a -e /proc/$PID ]; then
    echo "process exists"
fi
```
ou
```
if [ -n "$(ps -p $PID -o pid=)" ]
```
Dans cette dernière forme, -o pid= est un format de sortie pour l'affichage de l'ID de processus colonne sans en-tête. Les citations sont nécessaire de chaîne non vide opérateur -n donner de résultat valable.
- La deuxième méthode fonctionne sur Mac aussi, comme un ajout plus (Mac OS X n'a pas de /proc FS). Vous pouvez, cependant, évitez d'utiliser un shell interne est exécuté et l'utiliser sur Mac et Linux: if ps -p"$PID" -o "pid=" >/dev/null 2>&1; then echo "Process is running..."; fi
- Malheureusement, ps les options et les fonctionnalités ont tendance à varier entre les plates-formes, donc c'est pas encore tout à fait portable.
- si $PID est vide alors [ -e /proc/$PID ] retournera toujours le cas, puisque le /proc/ répertoire existe encore.
InformationsquelleAutor user2683246

ps de commande avec -p $PID pouvez faire ceci:

$ ps -p 3531
  PID TTY          TIME CMD
 3531 ?        00:03:07 emacs

InformationsquelleAutor oherrala

11

Vous avez deux façons:

Permet de commencer par la recherche d'une application spécifique dans mon ordinateur portable:
```
[root@pinky:~]# ps fax | grep mozilla
 3358 ?        S      0:00  \_ /bin/sh /usr/lib/firefox-3.5/run-mozilla.sh /usr/lib/firefox-3.5/firefox
16198 pts/2    S+     0:00              \_ grep mozilla
```
Tous les exemples maintenant va chercher PID 3358.

Première: Run "ps aux" et grep pour le PID dans la deuxième colonne. Dans cet exemple, je regarde pour firefox, et puis pour qu'il PID:
```
[root@pinky:~]# ps aux | awk '{print $2 }' | grep 3358
3358
```
De sorte que votre code sera:
```
if [ ps aux | awk '{print $2 }' | grep -q $PID 2> /dev/null ]; then
    kill $PID 
fi
```
Deuxième façon: il suffit de regarder pour quelque chose dans la /proc/$PID répertoire. Je suis à l'aide de "exe" dans cet exemple, mais vous pouvez utiliser n'importe quoi d'autre.
```
[root@pinky:~]# ls -l /proc/3358/exe 
lrwxrwxrwx. 1 elcuco elcuco 0 2010-06-15 12:33 /proc/3358/exe -> /bin/bash
```
De sorte que votre code sera:
```
if [ -f /proc/$PID/exe ]; then
    kill $PID 
fi
```
BTW: quoi de mal avec kill -9 $PID || true ?

EDIT:

Après y avoir réfléchi pendant quelques mois.. (sur 24...) l'idée originale que j'ai donné ici est un hack sympa, mais très portables. Alors qu'il enseigne quelques détails de mise en œuvre de Linux, il ne pourra pas fonctionner sur Mac, Solaris ou *BSD. Il peut même échouer sur les futurs noyaux Linux. Veuillez utiliser "ps" comme décrit dans d'autres réponses.
- au moins le kill -9 partie semble mal (ne pas tuer les sous-processus)
- Pourquoi puis-je obtenir [: manquant `]' lors de l'utilisation de la première méthode?
- qu'avez-vous exactement utilisé comme une commande?
- /proc/$PID/exe n'est pas un fichier régulier. Donc, [ -f /proc/$PID/exe ] sera renvoie toujours une false résultat. Essayez [ -h /proc/$PID/exe ].
InformationsquelleAutor elcuco
8

Je pense que c'est une mauvaise solution, qui s'ouvre pour les conditions de course. Que faire si le processus meurt entre votre essai et votre appel à tuer? Puis de tuer sera un échec. Alors pourquoi ne pas simplement essayer de le tuer dans tous les cas, et vérifier sa valeur de retour pour savoir comment ça s'est passé?
- +1 malheureusement tuer(1) le code de sortie n'a pas à distinguer les différentes situations d'erreur (dirait qu'il incrémente la valeur de sortie par un pour chaque processus de l'échec du signal). si l'OP n'a pas l'esprit de la rédaction de leur propre kill(2) wrapper, il pourrait l'avoir sortie avec différentes valeurs en fonction de la valeur de ERRNO après l'échec d'une kill(2) appel.
- pour le moment, je suis juste à faire kill -9 sans vérifier - je viens d'obtenir une erreur "le processus n'existe pas" s'il n'existe pas, ce qui n'est pas très bien rangé. Comment pourrais-je le test ce qui s'est passé?
- Ne pas négligemment kill -9. Que juste tue instantanément le processus en lui donnant aucune chance à nettoyer après lui-même. Au lieu d'utiliser kill qui est équivalent à kill -15. Si cela ne fonctionne pas, vous devez savoir pourquoi, et qu'en dernier recours, l'utilisation kill -9.
InformationsquelleAutor unwind
5

Il semble que vous voulez
```
wait $PID
```
qui sera de retour lors de la $pid finitions.

Sinon, vous pouvez utiliser
```
ps -p $PID
```
pour vérifier si le processus est toujours en vie (ce qui est plus efficace que kill -0 $pid car il fonctionne même si vous n'avez pas le pid).
- attendre n'est pas aussi efficace que le processus devrait être de l'enfant de shell en cours ou cela va donner : pid 123 is not a child of this shell
InformationsquelleAutor Gagan Gami

code ci-dessous vérifie si mon processus est en cours, si oui, ne rien faire.

nous allons vérifier les nouveaux messages à partir d'Amazon SQS chaque heure si, et seulement si le processus n'est pas en cours d'exécution.

#!/bin/bash
PID=$(ps aux | grep '/usr/bin/python2.7 manage.py SES__boto3_sqs_read' | grep -v grep | awk '{print $2}')
if [[ -z $PID ]]; then
    /usr/bin/python2.7 /home/brian/djcode/proyectoONE/manage.py SES__boto3_sqs_read
else
    echo "do nothing, just smile =)"
fi
exit $?

InformationsquelleAutor Brian Sanchez

0

ici je stocker le PID dans un fichier appelé .pid (qui est une sorte de /exécuter/...) et seulement exécuter le script si ce n'est déjà en cours d'exécution.
```
#!/bin/bash
if [ -f .pid ]; then
  read pid < .pid
  echo $pid
  ps -p $pid > /dev/null
  r=$?
  if [ $r -eq 0 ]; then
    echo "$pid is currently running, not executing $0 twice, exiting now..."
    exit 1
  fi
fi

echo $$ > .pid

# do things here

rm .pid
```
remarque: il y a une race condition qu'il ne vérifie pas comment ce pid est appelé. si le système est redémarré et .pid existe mais il est utilisé par une autre application, cela pourrait mener une "conséquences imprévues'.

InformationsquelleAutor invalidmagic
0

Par exemple dans GNU/Linux, vous pouvez utiliser:
```
Pid=$(pidof `process_name`)

if [ $Pid > 0 ]; then

   do something
else

   do something
fi 
```
Ou quelque chose comme
```
Pin=$(ps -A | grep name | awk 'print $4}')
echo $PIN
```
et qui vous indique le nom de l'application, il suffit de le nom, sans IDENTITÉ.
- pidof ne renvoie pas à un nombre négatif, que négatif PID n'a aucun sens, et vous ne pouvez pas tuer init, de sorte que votre conditionnelle n'a pas de sens (et d'ailleurs, vous auriez besoin pour échapper à la > pour empêcher d'effectuer une redirection). Vous voulez vérifier un résultat vide, mais bien sûr, comme tout bon outil, pidof définit un code de sortie pour vous dire si ça a marché, donc la solution appropriée est if Pid=$(pidof 'process_name'); then ... ou (si vous n'avez pas besoin de valeur dans Pid plus tard), il suffit de if pidof 'process_name'; then...
- est bon, le pidof exemple est pleine de malentendus au sujet de la façon dont bash test œuvres. gnu.org/software/bash/manual/html_node/...
InformationsquelleAutor inukaze

Vous devez vous connecter pour publier un commentaire.

DISCUSSION