Come verificare se esiste un processo con un dato pid in Python?

C'è un modo per verificare se un pid corrisponde a un processo valido? Ricevo un pid da una fonte diversa da quella os.getpid()e devo controllare se un processo con quel pid non esiste sulla macchina.

Ho bisogno che sia disponibile in Unix e Windows. Sto anche controllando se il PID NON è in uso.

L'invio del segnale 0 a un pid solleverà un'eccezione OSError se il pid non è in esecuzione e non farà nulla altrimenti.

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

Dai un'occhiata al psutilmodulo:

psutil (sistema python e utilità di processo) è una libreria multipiattaforma per il recupero di informazioni sui processi in esecuzione e sull'utilizzo del sistema (CPU, memoria, dischi, rete) in Python. [...] Attualmente supporta Linux , Windows , OSX , FreeBSD e Sun Solaris , architetture sia a 32 bit che a 64 bit , con versioni di Python dalla 2.6 alla 3.4 (gli utenti di Python 2.4 e 2.5 possono usare la versione 2.1.3) . PyPy è anche noto per funzionare.

Ha una funzione chiamata pid_exists()che puoi usare per verificare se esiste un processo con il dato pid.

Ecco un esempio:

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)

Per riferimento:

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

Il codice mluebke non è corretto al 100%; kill () può anche aumentare EPERM (accesso negato) nel qual caso ciò significa ovviamente che esiste un processo. Questo dovrebbe funzionare:

(modificato secondo i commenti di 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

Non puoi farlo su Windows a meno che non usi pywin32, ctypes o un modulo di estensione C. Se ti va bene dipendere da una libreria esterna puoi usare psutil :

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

Le risposte che implicano l'invio di "segnale 0" al processo funzioneranno solo se il processo in questione è di proprietà dell'utente che esegue il test . Altrimenti si otterrà un a OSErrorcausa dei permessi , anche se il pid esiste nel sistema.

Per aggirare questa limitazione puoi verificare se /proc/<pid>esiste:

import os

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

Questo vale solo per i sistemi basati su Linux, ovviamente.

In Python 3.3+, potresti usare nomi di eccezioni invece di costanti errno. Versione 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

Cerca qui il modo specifico per Windows per ottenere l'elenco completo dei processi in esecuzione con i loro ID. Sarebbe qualcosa di simile

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]

È quindi possibile verificare il pid ottenuto rispetto a questo elenco. Non ho idea del costo delle prestazioni, quindi è meglio che controlli questo se hai intenzione di eseguire spesso la verifica del PID.

Per * NIx, usa semplicemente la soluzione di mluebke.

Basandosi su ntrrgc ho potenziato la versione di Windows in modo che controlli il codice di uscita del processo e controlli le autorizzazioni:

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 la risposta di Giampaolo Rodolà per POSIX e la mia per Windows ho ottenuto questo:

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

In Windows, puoi farlo in questo modo:

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

Prima di tutto, in questo codice provi a ottenere un handle per il processo con pid dato. Se l'handle è valido, chiudere l'handle per il processo e restituire True; in caso contrario, restituisci False. Documentazione per OpenProcess: https://msdn.microsoft.com/en-us/library/windows/desktop/ms684320%28v=vs.85%29.aspx

Funzionerà per Linux, ad esempio se vuoi controllare se banshee è in esecuzione ... (banshee è un lettore musicale)

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")

Direi che usa il PID per qualsiasi scopo lo stai ottenendo e gestisci gli errori con grazia. Altrimenti, è una gara classica (il PID potrebbe essere valido quando controlli che sia valido, ma sparisci un istante dopo)