Làm thế nào để kiểm tra xem có tồn tại một quy trình với một pid nhất định trong Python không?

Có cách nào để kiểm tra xem một pid có tương ứng với một quy trình hợp lệ không? Tôi đang nhận được một pid từ một nguồn khác với từ đó os.getpid()và tôi cần kiểm tra xem liệu quá trình với pid đó có tồn tại trên máy hay không.

Tôi cần nó có sẵn trong Unix và Windows. Tôi cũng đang kiểm tra xem PID KHÔNG được sử dụng hay không.

Việc gửi tín hiệu 0 tới một pid sẽ tạo ra ngoại lệ OSError nếu pid không chạy và không làm gì khác.

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

Hãy xem psutilmô-đun:

psutil (hệ thống python và tiện ích quy trình) là một thư viện đa nền tảng để truy xuất thông tin về các quy trình đang chạy và việc sử dụng hệ thống (CPU, bộ nhớ, đĩa, mạng) bằng Python. [...] Nó hiện hỗ trợ Linux , Windows , OSX , FreeBSD và Sun Solaris , cả kiến trúc 32 bit và 64 bit , với các phiên bản Python từ 2.6 đến 3.4 (người dùng Python 2.4 và 2.5 có thể sử dụng phiên bản 2.1.3) . PyPy cũng được biết là hoạt động.

Nó có một chức năng được gọi là pid_exists()bạn có thể sử dụng để kiểm tra xem một tiến trình với pid đã cho có tồn tại hay không.

Đây là một ví dụ:

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)

Để tham khảo:

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

mã mluebke không đúng 100%; kill () cũng có thể tăng EPERM (quyền truy cập bị từ chối) trong trường hợp đó, điều đó rõ ràng có nghĩa là một quá trình tồn tại. Điều này được cho là hoạt động:

(được chỉnh sửa theo bình luận của 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

Bạn không thể thực hiện việc này trên Windows trừ khi bạn sử dụng pywin32, ctypes hoặc mô-đun mở rộng C. Nếu bạn đồng ý với việc phụ thuộc vào lib bên ngoài, bạn có thể sử dụng psutil :

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

Các câu trả lời liên quan đến việc gửi 'tín hiệu 0' tới quy trình sẽ chỉ hoạt động nếu quy trình được đề cập thuộc sở hữu của người dùng đang chạy thử nghiệm . Nếu không, bạn sẽ nhận được quyềnOSError truy cập đến hạn , ngay cả khi pid tồn tại trong hệ thống.

Để vượt qua giới hạn này, bạn có thể kiểm tra xem có /proc/<pid>tồn tại hay không:

import os

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

Rõ ràng là điều này chỉ áp dụng cho các hệ thống dựa trên linux.

Trong Python 3.3+, bạn có thể sử dụng tên ngoại lệ thay vì hằng số errno. Phiên bản 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

Hãy xem ở đây để biết cách dành riêng cho windows để nhận danh sách đầy đủ các quy trình đang chạy với ID của chúng. Nó sẽ giống như

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]

Sau đó, bạn có thể xác minh pid bạn nhận được trong danh sách này. Tôi không có ý kiến ​​về chi phí hiệu suất, vì vậy bạn nên kiểm tra điều này nếu bạn định thực hiện xác minh pid thường xuyên.

Đối với * NIx, chỉ cần sử dụng giải pháp của mluebke.

Xây dựng dựa trên ntrrgc, tôi đã củng cố phiên bản windows để nó kiểm tra mã thoát quy trình và kiểm tra quyền:

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

Kết hợp câu trả lời của Giampaolo Rodolà cho POSIX và câu trả lời của tôi cho Windows, tôi nhận được câu này:

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

Trong Windows, bạn có thể thực hiện theo cách này:

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

Trước hết, trong đoạn mã này, bạn cố gắng xử lý quá trình với pid đã cho. Nếu xử lý hợp lệ, sau đó đóng xử lý cho tiến trình và trả về True; nếu không, bạn trả về False. Tài liệu cho OpenProcess: https://msdn.microsoft.com/en-us/library/windows/desktop/ms684320%28v=vs.85%29.aspx

Điều này sẽ hoạt động đối với Linux, chẳng hạn nếu bạn muốn kiểm tra xem banshee có đang chạy hay không ... (banshee là một trình phát nhạc)

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

Tôi muốn nói rằng hãy sử dụng PID cho bất kỳ mục đích nào bạn đang lấy nó và xử lý các lỗi một cách khéo léo. Nếu không, đó là một cuộc đua cổ điển (PID có thể hợp lệ khi bạn kiểm tra nó hợp lệ, nhưng biến mất ngay sau đó)