Python'da belirli bir pid ile bir işlem olup olmadığı nasıl kontrol edilir?

Bir pid'nin geçerli bir sürece karşılık gelip gelmediğini kontrol etmenin bir yolu var mı? Kaynak dışında farklı bir kaynaktan bir pid alıyorum os.getpid()ve bu pid ile bir işlemin makinede olup olmadığını kontrol etmem gerekiyor.

Unix ve Windows'ta bulunmasına ihtiyacım var. Ayrıca PID'nin kullanımda OLMADIĞINI kontrol ediyorum.

0 sinyalini bir pid'e göndermek, pid çalışmıyorsa bir OSError istisnası ortaya çıkarır ve başka türlü bir şey yapmaz.

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

psutilModüle bir göz atın :

psutil (python sistemi ve işlem yardımcı programları), Python'da çalışan işlemler ve sistem kullanımı (CPU, bellek, diskler, ağ) hakkında bilgi almak için bir çapraz platform kitaplığıdır . [...] Şu anda hem 32-bit hem de 64-bit mimarileri olan Linux , Windows , OSX , FreeBSD ve Sun Solaris'i desteklemektedir ve Python sürümleri 2.6'dan 3.4'e kadardır (Python 2.4 ve 2.5 kullanıcıları 2.1.3 sürümünü kullanabilir) . PyPy'nin de çalıştığı bilinmektedir.

pid_exists()Verilen pid ile bir işlemin var olup olmadığını kontrol etmek için kullanabileceğiniz adında bir işlevi vardır.

İşte bir örnek:

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)

Referans için:

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

mluebke kodu% 100 doğru değil; kill () ayrıca EPERM'yi (erişim reddedildi) yükseltebilir, bu durumda bu açıkça bir sürecin var olduğu anlamına gelir. Bunun işe yaraması gerekiyor:

(Jason R. Coombs yorumlarına göre düzenlendi)

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

Pywin32, ctypes veya bir C genişletme modülü kullanmadığınız sürece bunu Windows'ta yapamazsınız. Harici bir kitaplığa bağlı olarak sorun yoksa, psutil'i kullanabilirsiniz :

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

İşleme "0 sinyali" gönderilmesini içeren yanıtlar, yalnızca söz konusu işlemin testi çalıştıran kullanıcıya ait olması durumunda işe yarayacaktır . Aksi takdirde , sistemde pid mevcut olsa bile izinlerOSError nedeniyle bir alacaksınız .

Bu sınırlamayı aşmak için /proc/<pid>var olup olmadığını kontrol edebilirsiniz :

import os

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

Açıkçası bu, yalnızca linux tabanlı sistemler için geçerlidir.

Python 3.3+ sürümünde, errno sabitleri yerine istisna adları kullanabilirsiniz. Posix sürümü :

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

Bakın burada kendi kimlikleri ile çalışan işlem tam listesini alma pencereleri özgü yol. Gibi bir şey olurdu

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]

Daha sonra bu listeye karşı aldığınız pid'i doğrulayabilirsiniz. Performans maliyeti hakkında hiçbir fikrim yok, bu yüzden sık sık pid doğrulaması yapacaksanız bunu kontrol etseniz iyi olur.

* NIx için mluebke'nin çözümünü kullanın.

Ntrrgc'leri temel alarak Windows sürümünü güçlendirdim, böylece işlem çıkış kodunu kontrol eder ve izinleri kontrol eder:

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

Giampaolo Rodolà'nın POSIX cevabını ve Windows için benimkini birleştirerek şunu anladım:

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

Windows'ta bunu şu şekilde yapabilirsiniz:

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

Öncelikle bu kodda verilen pid ile işlem için bir tutamaç elde etmeye çalışıyorsunuz. Tanıtıcı geçerliyse, işlem için tanıtıcıyı kapatın ve True döndür; aksi takdirde False döndürürsünüz. OpenProcess için Belgeler: https://msdn.microsoft.com/en-us/library/windows/desktop/ms684320%28v=vs.85%29.aspx

Bu, Linux için çalışacaktır, örneğin banshee'nin çalışıp çalışmadığını kontrol etmek istiyorsanız ... (banshee bir müzik çalar)

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

Aşağıdaki kod hem Linux hem de Windows üzerinde çalışır ve harici modüllere bağlı değildir

import os
import subprocess
import platform
import re

def pid_alive(pid:int):
    """ Check For whether a pid is alive """


    system = platform.uname().system
    if re.search('Linux', system, re.IGNORECASE):
        try:
            os.kill(pid, 0)
        except OSError:
            return False
        else:
            return True
    elif re.search('Windows', system, re.IGNORECASE):
        out = subprocess.check_output(["tasklist","/fi",f"PID eq {pid}"]).strip()
        # b'INFO: No tasks are running which match the specified criteria.'

        if re.search(b'No tasks', out, re.IGNORECASE):
            return False
        else:
            return True
    else:
        raise RuntimeError(f"unsupported system={system}")

İhtiyaç duymanız durumunda kolayca geliştirilebilir

1. diğer platformlar
2. diğer dil

PID'yi hangi amaçla elde ediyorsanız kullanın ve hataları nazikçe halledin derim. Aksi takdirde, bu klasik bir yarış (PID geçerli olduğunu kontrol ettiğinizde geçerli olabilir, ancak bir an sonra kaybolur)