Wie kann ich überprüfen, ob in Python ein Prozess mit einer bestimmten PID vorhanden ist?

Gibt es eine Möglichkeit zu überprüfen, ob eine PID einem gültigen Prozess entspricht? Ich erhalte eine PID von einer anderen Quelle als von os.getpid()und muss überprüfen, ob auf dem Computer kein Prozess mit dieser PID vorhanden ist.

Ich brauche es, um unter Unix und Windows verfügbar zu sein. Ich überprüfe auch, ob die PID NICHT verwendet wird.

Das Senden des Signals 0 an eine PID löst eine OSError-Ausnahme aus, wenn die PID nicht ausgeführt wird, und führt nichts anderes aus.

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

Schauen Sie sich das psutilModul an:

psutil (Python-System- und Prozessdienstprogramme) ist eine plattformübergreifende Bibliothek zum Abrufen von Informationen zum Ausführen von Prozessen und zur Systemauslastung (CPU, Speicher, Festplatten, Netzwerk) in Python. [...] Es unterstützt derzeit Linux , Windows , OSX , FreeBSD und Sun Solaris , sowohl 32-Bit- als auch 64-Bit- Architekturen, mit Python-Versionen von 2.6 bis 3.4 (Benutzer von Python 2.4 und 2.5 können die Version 2.1.3 verwenden). . Es ist auch bekannt, dass PyPy funktioniert.

Es hat eine Funktion namens pid_exists(), mit der Sie überprüfen können, ob ein Prozess mit der angegebenen PID vorhanden ist.

Hier ist ein Beispiel:

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)

Als Referenz:

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

mluebke Code ist nicht 100% korrekt; kill () kann auch EPERM (Zugriff verweigert) auslösen. In diesem Fall bedeutet dies offensichtlich, dass ein Prozess vorhanden ist. Das soll funktionieren:

(bearbeitet gemäß den Kommentaren von 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

Sie können dies unter Windows nur tun, wenn Sie pywin32, ctypes oder ein C-Erweiterungsmodul verwenden. Wenn Sie mit der Abhängigkeit von einer externen Bibliothek einverstanden sind, können Sie psutil verwenden :

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

Die Antworten zum Senden von 'Signal 0' an den Prozess funktionieren nur, wenn der betreffende Prozess dem Benutzer gehört, der den Test ausführt . Andernfalls erhalten Sie OSErroraufgrund von Berechtigungen eine , auch wenn die PID im System vorhanden ist.

Um diese Einschränkung zu umgehen, können Sie überprüfen, ob /proc/<pid>Folgendes vorhanden ist:

import os

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

Dies gilt natürlich nur für Linux-basierte Systeme.

In Python 3.3+ können Sie Ausnahmenamen anstelle von errno-Konstanten verwenden. 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

Suchen Sie hier nach einer Windows-spezifischen Methode, um eine vollständige Liste der ausgeführten Prozesse mit ihren IDs abzurufen. Es wäre so etwas wie

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]

Sie können dann überprüfen, welche PID Sie für diese Liste erhalten. Ich habe keine Ahnung von den Leistungskosten, daher sollten Sie dies überprüfen, wenn Sie häufig eine PID-Überprüfung durchführen.

Verwenden Sie für * NIx einfach die Lösung von mluebke.

Aufbauend auf ntrrgc habe ich die Windows-Version verbessert, damit der Prozess-Exit-Code und die Berechtigungen überprüft werden:

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

Durch die Kombination von Giampaolo Rodolàs Antwort für POSIX und meiner für Windows habe ich Folgendes erhalten :

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 können Sie dies folgendermaßen tun:

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

Zunächst versuchen Sie in diesem Code, ein Handle für den Prozess mit der angegebenen PID zu erhalten. Wenn das Handle gültig ist, schließen Sie das Handle für den Prozess und geben Sie True zurück. Andernfalls geben Sie False zurück. Dokumentation für OpenProcess: https://msdn.microsoft.com/en-us/library/windows/desktop/ms684320%28v=vs.85%29.aspx

Dies funktioniert unter Linux, wenn Sie beispielsweise überprüfen möchten, ob Banshee ausgeführt wird ... (Banshee ist ein Musikplayer)

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

Ich würde sagen, verwenden Sie die PID für jeden Zweck, den Sie erhalten, und behandeln Sie die Fehler ordnungsgemäß. Ansonsten ist es ein klassisches Rennen (die PID kann gültig sein, wenn Sie überprüfen, ob sie gültig ist, aber einen Moment später verschwinden)