Question

我正在尝试使用多个进程创建一个程序，如果发生错误，我想干净地终止所有生成的进程。下面我已经写了一些伪类型代码，我认为我需要做什么，但我不知道最好的方法是与错误发生的所有进程进行通信，它们应该终止。

我认为我应该使用类来做这类事情，但我对Python很陌生，所以我只是想先了解基础知识。

#imports

exitFlag = True

# Function for threads to process   
def url_thread_worker( ):   
# while exitFlag:
    try:
        # do something
    except:
        # we've ran into a problem, we need to kill all the spawned processes and cleanly exit the program
        exitFlag = False

def processStarter( ):

    process_1 = multiprocessing.Process( name="Process-1", target=url_thread_worker, args=( ) ) 
    process_2 = multiprocessing.Process( name="Process-2", target=url_thread_worker, args=( ) ) 

    process_1.start()
    process_2.start()


if __name__ == '__main__':
     processStarter( )

提前致谢

Answer 1

这是我的建议：

import multiprocessing
import threading
import time

def good_worker():   
    print "[GoodWorker] Starting"
    time.sleep(4)
    print "[GoodWorker] all good"

def bad_worker():
    print "[BadWorker] Starting"
    time.sleep(2)
    raise Exception("ups!")

class MyProcManager(object):
    def __init__(self):
        self.procs = []
        self.errors_flag = False
        self._threads = []
        self._lock = threading.Lock()

    def terminate_all(self):
        with self._lock:
            for p in self.procs:
                if p.is_alive():
                    print "Terminating %s" % p
                    p.terminate()

    def launch_proc(self, func, args=(), kwargs= {}):
        t = threading.Thread(target=self._proc_thread_runner,
                             args=(func, args, kwargs))
        self._threads.append(t)
        t.start()

    def _proc_thread_runner(self, func, args, kwargs):
        p = multiprocessing.Process(target=func, args=args, kwargs=kwargs)
        self.procs.append(p)
        p.start()
        while p.exitcode is None:
            p.join()
        if p.exitcode > 0:
            self.errors_flag = True
            self.terminate_all()

    def wait(self):
        for t in self._threads:
            t.join()

if __name__ == '__main__':
    proc_manager = MyProcManager()
    proc_manager.launch_proc(good_worker) 
    proc_manager.launch_proc(good_worker) 
    proc_manager.launch_proc(bad_worker) 
    proc_manager.wait()
    if proc_manager.errors_flag:
        print "Errors flag is set: some process crashed"
    else:
        print "Everything closed cleanly"

您需要为每个进程运行一个包装器线程，等待其结束。当一个过程结束时，检查exitcode：if＆gt; 0，表示它引发了一些未处理的异常。现在调用terminate_all（）来关闭所有剩余的活动进程。包装线程也将完成，因为它们依赖于进程运行。

此外，在您的代码中，您可以随时调用proc_manager.terminate_all（）。您可以检查不同线程中的某些标志或类似的东西..

希望这对你的情况有好处。

PS：btw ..在您的原始代码中，您执行了类似全局exit_flag的操作：您在多处理中永远不会有“全局”exit_flag，因为它只是不是全局的，因为您使用具有独立内存空间的分离进程。这仅适用于可以共享状态的线程环境。如果您在多处理中需要它，那么您必须在流程（Pipe and Queue accomplish that）或类似shared memory objects

之间进行明确的沟通

Answer 2

如果您希望在父进程退出时自动终止子进程;你可以让它们成为守护进程（在.daemon=True之前设置.start()），即如果父进程检测到错误;它可能会放弃 - 孩子们会得到照顾。

如果你想让孩子自己清理;你可以use multiprocessing.Event() as a global flag：

import multiprocessing

def event_func(event):
    print '\t%r is waiting' % multiprocessing.current_process()
    event.wait()
    print '\t%r has woken up' % multiprocessing.current_process()

if __name__ == '__main__':
    event = multiprocessing.Event()

    processes = [multiprocessing.Process(target=event_func, args=(event,))
                 for i in range(5)]

    for p in processes:
        p.start()

    print 'main is sleeping'
    time.sleep(2)

    print 'main is setting event'
    event.set()

    for p in processes:
        p.join()

根据退出标志清除Python多进程终止

2 个答案: