¿Cómo comprobar si existe un proceso con un pid dado en Python?

Question

¿Hay alguna manera de verificar si un pid corresponde a un proceso válido? Obtengo un pid de una fuente diferente que no sea os.getpid() y necesito verificar si un proceso con ese pid no existe en la máquina.

Necesito que esté disponible en Unix y Windows. También estoy verificando si el PID NO está en uso.

Answer 1

La señal de envío 0 a un pid generará una excepción OSError si el pid no se está ejecutando, y no hará nada de lo contrario.

import os 

def check_pid(pid):   
    """ Check For the existence of a unix pid. """ 
    try: 
     os.kill(pid, 0) 
    except OSError: 
     return False 
    else: 
     return True 

Answer 2

Look here de manera de obtener la lista completa de los procesos en ejecución con sus identificaciones específicas de Windows. Sería algo así como

from win32com.client import GetObject 
def get_proclist(): 
    WMI = GetObject('winmgmts:') 
    processes = WMI.InstancesOf('Win32_Process') 
    return [process.Properties_('ProcessID').Value for process in processes] 

A continuación, puede verificar pid que obtiene en contra de esta lista. No tengo idea del costo de rendimiento, así que será mejor que lo compruebes si vas a hacer la verificación de pid a menudo.

Para * NIx, solo use la solución de mluebke.

Answer 3

Yo diría que use el PID para cualquier propósito que lo esté obteniendo y maneje los errores con gracia. De lo contrario, es una carrera clásica (el PID puede ser válido cuando se comprueba que es válido, pero se va un instante después)

Answer 4

mluebke código no es 100% correcto; kill() también puede generar EPERM (acceso denegado), en cuyo caso eso obviamente significa que existe un proceso. Esto se supone que funciona:

(editado de acuerdo con los comentarios de Jason R. Coombs)

import errno 
import os 
import sys 

def pid_exists(pid): 
    """Check whether pid exists in the current process table. 
    UNIX only. 
    """ 
    if pid < 0: 
     return False 
    if pid == 0: 
     # According to "man 2 kill" PID 0 refers to every process 
     # in the process group of the calling process. 
     # On certain systems 0 is a valid PID but we have no way 
     # to know that in a portable fashion. 
     raise ValueError('invalid PID 0') 
    try: 
     os.kill(pid, 0) 
    except OSError as err: 
     if err.errno == errno.ESRCH: 
      # ESRCH == No such process 
      return False 
     elif err.errno == errno.EPERM: 
      # EPERM clearly means there's a process to deny access to 
      return True 
     else: 
      # According to "man 2 kill" possible error values are 
      # (EINVAL, EPERM, ESRCH) 
      raise 
    else: 
     return True 

No se puede hacer esto en Windows a menos que utilice pywin32, ctypes o un módulo de extensión C. Si estás bien con función de un lib externa puede utilizar psutil:

>>> import psutil 
>>> psutil.pid_exists(2353) 
True 

Answer 5

Tenga una mirada en el módulo psutil:

psutil (sistema de pitón y servicios de proceso) es una biblioteca multiplataforma para recuperar información en procesos en ejecución y utilización del sistema (CPU, memoria, discos, red) en Python. [...] En la actualidad apoya Linux, de Windows, OSX, FreeBSD y Sun Solaris, dos de 32 bits y64 bits arquitecturas, con versiones de Python desde 2,6 a 3.4 (los usuarios de Python 2.4 y 2.5 pueden usar la versión 2.1.3). PyPy también se sabe que funciona.

Tiene una función llamada pid_exists() que puede usar para verificar si existe un proceso con el pid dado.

Aquí está un ejemplo:

import psutil 
pid = 12345 
if psutil.pid_exists(pid): 
    print "a process with pid %d exists" % pid 
else: 
    print "a process with pid %d does not exist" % pid 

para la referencia:

• https://pypi.python.org/pypi/psutil
• https://github.com/giampaolo/psutil
• http://pythonhosted.org/psutil/#psutil.pid_exists

Answer 6

Combinando Giampaolo Rodolà's answer for POSIX y mine for Windows Tengo esto:

import os 
if os.name == 'posix': 
    def pid_exists(pid): 
     """Check whether pid exists in the current process table.""" 
     import errno 
     if pid < 0: 
      return False 
     try: 
      os.kill(pid, 0) 
     except OSError as e: 
      return e.errno == errno.EPERM 
     else: 
      return True 
else: 
    def pid_exists(pid): 
     import ctypes 
     kernel32 = ctypes.windll.kernel32 
     SYNCHRONIZE = 0x100000 

     process = kernel32.OpenProcess(SYNCHRONIZE, 0, pid) 
     if process != 0: 
      kernel32.CloseHandle(process) 
      return True 
     else: 
      return False 

Answer 7

En Python 3.3+, se puede usar nombres de excepción en lugar de constantes errno. Posix version:

import os 

def pid_exists(pid): 
    if pid < 0: return False #NOTE: pid == 0 returns True 
    try: 
     os.kill(pid, 0) 
    except ProcessLookupError: # errno.ESRCH 
     return False # No such process 
    except PermissionError: # errno.EPERM 
     return True # Operation not permitted (i.e., process exists) 
    else: 
     return True # no error, we can send a signal to the process 

Answer 8

Sobre la base de ntrrgc He reforzado la versión ventanas, así que comprueba el código de salida del proceso y los controles de permisos:

def pid_exists(pid): 
    """Check whether pid exists in the current process table.""" 
    if os.name == 'posix': 
     import errno 
     if pid < 0: 
      return False 
     try: 
      os.kill(pid, 0) 
     except OSError as e: 
      return e.errno == errno.EPERM 
     else: 
      return True 
    else: 
     import ctypes 
     kernel32 = ctypes.windll.kernel32 
     HANDLE = ctypes.c_void_p 
     DWORD = ctypes.c_ulong 
     LPDWORD = ctypes.POINTER(DWORD) 
     class ExitCodeProcess(ctypes.Structure): 
      _fields_ = [ ('hProcess', HANDLE), 
       ('lpExitCode', LPDWORD)] 

     SYNCHRONIZE = 0x100000 
     process = kernel32.OpenProcess(SYNCHRONIZE, 0, pid) 
     if not process: 
      return False 

     ec = ExitCodeProcess() 
     out = kernel32.GetExitCodeProcess(process, ctypes.byref(ec)) 
     if not out: 
      err = kernel32.GetLastError() 
      if kernel32.GetLastError() == 5: 
       # Access is denied. 
       logging.warning("Access is denied to get pid info.") 
      kernel32.CloseHandle(process) 
      return False 
     elif bool(ec.lpExitCode): 
      # print ec.lpExitCode.contents 
      # There is an exist code, it quit 
      kernel32.CloseHandle(process) 
      return False 
     # No exit code, it's running. 
     kernel32.CloseHandle(process) 
     return True 

Answer 9

Esto funciona para Linux, por ejemplo, si desea para comprobar si se está ejecutando alma en pena ... (Banshee es un reproductor de música)

import subprocess 

def running_process(process): 
    "check if process is running. <process> is the name of the process." 

    proc = subprocess.Popen(["if pgrep " + process + " >/dev/null 2>&1; then echo 'True'; else echo 'False'; fi"], stdout=subprocess.PIPE, shell=True) 

    (Process_Existance, err) = proc.communicate() 
    return Process_Existance 

# use the function 
print running_process("banshee") 

Answer 10

en Windows, puede hacerlo de esta manera:

import ctypes 
PROCESS_QUERY_INFROMATION = 0x1000 
def checkPid(pid): 
    processHandle = ctypes.windll.kernel32.OpenProcess(PROCESS_QUERY_INFROMATION, 0,pid) 
    if processHandle == 0: 
     return False 
    else: 
     ctypes.windll.kernel32.CloseHandle(processHandle) 
    return True 

En primer lugar, en este código intenta obtener un control para el proceso con pid dado. Si el identificador es válido, cierre el identificador del proceso y devuelva True; de lo contrario, devuelve False. Documentación para OpenProcess: https://msdn.microsoft.com/en-us/library/windows/desktop/ms684320%28v=vs.85%29.aspx

Answer 11

Las respuestas que envían el envío de la 'señal 0' al proceso funcionarán en solo si el proceso en cuestión es propiedad del usuario que ejecuta la prueba. De lo contrario, obtendrá un OSError debido a permisos, incluso si el pid existe en el sistema.

Con el fin de evitar esta limitación se puede comprobar si existe /proc/<pid>:

import os 

def is_running(pid): 
    if os.path.isdir('/proc/{}'.format(pid)): 
     return True 
    return False