quy trình con: xóa quy trình con trong Windows

Question

Trên Windows, subprocess.Popen.terminate gọi số TerminalProcess của win32. Tuy nhiên, hành vi tôi thấy là quá trình con của quá trình tôi đang cố gắng chấm dứt vẫn đang chạy. Tại sao vậy? Làm thế nào để đảm bảo tất cả các tiến trình con bắt đầu bởi quá trình này bị giết?

Answer 1

Bằng cách sử dụng psutil:

import psutil, os 

def kill_proc_tree(pid, including_parent=True):  
    parent = psutil.Process(pid) 
    children = parent.children(recursive=True) 
    for child in children: 
     child.kill() 
    gone, still_alive = psutil.wait_procs(children, timeout=5) 
    if including_parent: 
     parent.kill() 
     parent.wait(5) 

me = os.getpid() 
kill_proc_tree(me) 

Answer 2

Đây là một việc khó làm. Windows không thực sự lưu trữ một cây xử lý trong không gian tiến trình. Cũng không thể chấm dứt một quá trình và chỉ ra rằng đó là trẻ em cũng nên chết.

Một cách xung quanh đó là sử dụng taskkill và yêu cầu nó chặn toàn bộ cây.

Một cách khác để làm điều đó (giả sử rằng bạn đang đẻ trứng quá trình cấp cao nhất) là sử dụng một mô-đun đã được phát triển với các loại điều này trong tâm trí: http://benjamin.smedbergs.us/blog/tag/killableprocess/

Để làm được điều này quát cho chính mình , bạn phải dành thời gian xây dựng danh sách ngược. Đó là, một quá trình lưu trữ con trỏ đến PARENT của nó, nhưng cha mẹ dường như không lưu trữ thông tin về trẻ em.

Vì vậy, bạn phải xem xét tất cả các quy trình trong hệ thống (thực sự không khó), sau đó tự kết nối các dấu chấm bằng cách xem trường quy trình gốc. Sau đó, bạn chọn cây bạn quan tâm và đi bộ toàn bộ điều, giết chết từng nút lần lượt từng cái một.

Lưu ý rằng Windows không cập nhật con trỏ mẹ của con khi cha mẹ chết, vì vậy có thể có khoảng trống trong cây của bạn. Tôi không biết bất cứ điều gì bạn có thể làm về những điều đó.

Answer 3

Đặt trẻ em trong một NT Job object, sau đó bạn có thể giết chết tất cả trẻ em

Answer 4

Sử dụng taskkill với /T cờ

p = subprocess.Popen(...) 
<wait> 
subprocess.call(['taskkill', '/F', '/T', '/PID', str(p.pid)]) 

Cờ để taskkill có các tài liệu sau:

TASKKILL [/S system [/U username [/P [password]]]] 
     { [/FI filter] [/PID processid | /IM imagename] } [/T] [/F] 

/S system   Specifies the remote system to connect to. 
/U [domain\]user Specifies the user context under which the 
         command should execute. 
/P [password]  Specifies the password for the given user 
         context. Prompts for input if omitted. 
/FI filter   Applies a filter to select a set of tasks. 
         Allows "*" to be used. ex. imagename eq acme* 
/PID processid  Specifies the PID of the process to be terminated. 
         Use TaskList to get the PID. 
/IM imagename  Specifies the image name of the process 
         to be terminated. Wildcard '*' can be used 
         to specify all tasks or image names. 
/T      Terminates the specified process and any 
         child processes which were started by it. 
/F      Specifies to forcefully terminate the process(es). 
/?      Displays this help message. 

Hoặc đi bộ cây quá trình sử dụng comtypes và win32api:

def killsubprocesses(parent_pid): 
    '''kill parent and all subprocess using COM/WMI and the win32api''' 

    log = logging.getLogger('killprocesses') 

    try: 
     import comtypes.client 
    except ImportError: 
     log.debug("comtypes not present, not killing subprocesses") 
     return 

    logging.getLogger('comtypes').setLevel(logging.INFO) 

    log.debug('Querying process tree...') 

    # get pid and subprocess pids for all alive processes 
    WMI = comtypes.client.CoGetObject('winmgmts:') 
    processes = WMI.InstancesOf('Win32_Process') 
    subprocess_pids = {} # parent pid -> list of child pids 

    for process in processes: 
     pid = process.Properties_('ProcessID').Value 
     parent = process.Properties_('ParentProcessId').Value 
     log.trace("process %i's parent is: %s" % (pid, parent)) 
     subprocess_pids.setdefault(parent, []).append(pid) 
     subprocess_pids.setdefault(pid, []) 

    # find which we need to kill 
    log.debug('Determining subprocesses for pid %i...' % parent_pid) 

    processes_to_kill = [] 
    parent_processes = [parent_pid] 
    while parent_processes: 
     current_pid = parent_processes.pop() 
     subps = subprocess_pids[current_pid] 
     log.debug("process %i children are: %s" % (current_pid, subps)) 
     parent_processes.extend(subps) 
     processes_to_kill.extend(subps) 

    # kill the subprocess tree 
    if processes_to_kill: 
     log.info('Process pid %i spawned %i subprocesses, terminating them...' % 
      (parent_pid, len(processes_to_kill))) 
    else: 
     log.debug('Process pid %i had no subprocesses.' % parent_pid) 

    import ctypes 
    kernel32 = ctypes.windll.kernel32 
    for pid in processes_to_kill: 
     hProcess = kernel32.OpenProcess(PROCESS_TERMINATE, FALSE, pid) 
     if not hProcess: 
      log.warning('Unable to open process pid %i for termination' % pid) 
     else: 
      log.debug('Terminating pid %i' % pid)       
      kernel32.TerminateProcess(hProcess, 3) 
      kernel32.CloseHandle(hProcess) 

Answer 5

Dưới đây là ví dụ mã cho phương pháp đối tượng công việc, nhưng thay vì subprocess nó sử dụng win32api.CreateProcess

import win32process 
import win32job 
startup = win32process.STARTUPINFO() 
(hProcess, hThread, processId, threadId) = win32process.CreateProcess(None, command, None, None, True, win32process.CREATE_BREAKAWAY_FROM_JOB, None, None, startup) 

hJob = win32job.CreateJobObject(None, '') 
extended_info = win32job.QueryInformationJobObject(hJob, win32job.JobObjectExtendedLimitInformation) 
extended_info['BasicLimitInformation']['LimitFlags'] = win32job.JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE 
win32job.SetInformationJobObject(hJob, win32job.JobObjectExtendedLimitInformation, extended_info) 
win32job.AssignProcessToJobObject(hJob, hProcess) 

Answer 6

tôi đã cùng một vấn đề và chỉ cần giết quá trình qua lệnh cửa sổ với tùy chọn giết trẻ em "/ T"

def kill_command_windows(pid): 
    '''Run command via subprocess''' 
    dev_null = open(os.devnull, 'w') 
    command = ['TASKKILL', '/F', '/T', '/PID', str(pid)] 
    proc = subprocess.Popen(command, stdin=dev_null, stdout=sys.stdout, stderr=sys.stderr)