Como verificar se existe um processo com um determinado pid em Python?

Existe uma maneira de verificar se um pid corresponde a um processo válido? Estou recebendo um pid de uma fonte diferente de os.getpid()e preciso verificar se um processo com esse pid não existe na máquina.

Eu preciso que ele esteja disponível no Unix e no Windows. Também estou verificando se o PID NÃO está em uso.

Enviar o sinal 0 para um pid levantará uma exceção OSError se o pid não estiver em execução e não fará nada de outra forma.

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

Dê uma olhada no psutilmódulo:

psutil (sistema python e utilitários de processo) é uma biblioteca de plataforma cruzada para recuperar informações sobre processos em execução e utilização do sistema (CPU, memória, discos, rede) em Python. [...] Atualmente suporta Linux , Windows , OSX , FreeBSD e Sun Solaris , ambas arquiteturas de 32 e 64 bits , com versões Python de 2.6 a 3.4 (usuários de Python 2.4 e 2.5 podem usar a versão 2.1.3) . PyPy também funciona.

Ele tem uma função chamada pid_exists()que você pode usar para verificar se existe um processo com o pid fornecido.

Aqui está um exemplo:

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 referência:

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

O código mluebke não está 100% correto; kill () também pode aumentar EPERM (acesso negado), caso em que isso obviamente significa que existe um processo. Isso deve funcionar:

(editado de acordo com os comentários de Jason R. Coombs)

import errno
import os

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

Você não pode fazer isso no Windows, a menos que use pywin32, ctypes ou um módulo de extensão C. Se você concordar em depender de uma biblioteca externa, poderá usar o psutil :

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

As respostas envolvendo o envio de 'sinal 0' para o processo funcionarão apenas se o processo em questão pertencer ao usuário que está executando o teste . Caso contrário, você obterá um OSErrordevido às permissões , mesmo se o pid existir no sistema.

Para contornar essa limitação, você pode verificar se /proc/<pid>existe:

import os

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

Isso se aplica apenas a sistemas baseados em Linux, obviamente.

No Python 3.3+, você pode usar nomes de exceção em vez de constantes errno. Versão Posix :

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

Procure aqui uma maneira específica do Windows de obter uma lista completa dos processos em execução com seus IDs. Seria algo 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]

Você pode então verificar o pid obtido nesta lista. Não tenho ideia sobre o custo de desempenho, então é melhor você verificar isso se for fazer a verificação pid com frequência.

Para * NIx, apenas use a solução do mluebke.

Com base no ntrrgc, reforcei a versão do Windows para que ele verifique o código de saída do processo e verifique as permissões:

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

Combinando a resposta de Giampaolo Rodolà para POSIX e a minha para Windows , obtive o seguinte:

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

No Windows, você pode fazer isso desta forma:

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

Em primeiro lugar, neste código você tenta obter um identificador para o processo com pid fornecido. Se o identificador for válido, feche o identificador para processo e retorne True; caso contrário, você retorna False. Documentação para OpenProcess: https://msdn.microsoft.com/en-us/library/windows/desktop/ms684320%28v=vs.85%29.aspx

Isso funcionará no Linux, por exemplo, se você quiser verificar se o banshee está rodando ... (o banshee é um reprodutor 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")

Eu diria que use o PID para qualquer propósito que você estiver obtendo e lide com os erros normalmente. Caso contrário, é uma corrida clássica (o PID pode ser válido quando você verifica se é válido, mas vá embora um instante depois)