Python 即使设置了超时，多处理也会挂起

Question

出于某种原因，我的程序在使用多处理和队列时挂起，即使我设置了超时并检查队列是否为空。 这发生在 Windows 和 Linux 上。

有多个进程接收输入（这里是 a、b 和 c）并且应该发送结果（这里它们只是发回输入 a、b 和 c）。

据我所知，在所有“给出参数”之后，他们一遍又一遍地发回 a 和 b 的结果，尽管 a 和 b 只提供一次。

import multiprocessing as mp
import queue

class Multithreading:
   def __init__(self, n_processes):
        self._processes = [
            _Thread(name='Process-{}'.format(i))
            for i in range(n_processes)]
    
    def __enter__(self):
        for process in self._processes:
            process.start()
            print(f'Started {process.name}')
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        for process in self._processes:
            process.event_stopped.set()
            process.join()
    
    def run(self):
        args = ['a', 'b', 'c']
    
        n_calls = len(args)
        for i, arg in enumerate(args):
            m = i % len(self._processes)
            print(f'Setting arguments to {self._processes[m].name}')
            is_started = False
            while not is_started:
                try:
                    self._processes[m].queue_inputs.put(arg, timeout=0.05)
                    is_started = True
                    print(f'Argument given to {self._processes[m].name}')
                except queue.Full:
                    pass
    
        print(f'All arguments given')
    
        for i in range(n_calls):
            m = i % len(self._processes)
            print(f'Checking result from {self._processes[m].name}')
            arg = None
            while True:
                try:
                    arg = self._processes[m].queue_results.get(timeout=0.05)
                    print('Received {}'.format(arg))
                    break
                except queue.Empty:
                    print(f'Empty in {self._processes[m].name}, arg = {arg}')
                    pass

class _Thread(mp.Process):
    def __init__(self, name):
        super().__init__(name=name, target=self._run)
        self.queue_inputs = mp.Queue()
        self.queue_results = mp.Queue()
        self.event_stopped = mp.Event()

    def _run(self):
        print(f'Running {self.name}')
        while not self.event_stopped.is_set():
            try:
                arg = self.queue_inputs.get(timeout=0.05)
                print(f'{self.name} received {arg}')
                while not self.event_stopped.is_set():
                    try:
                        self.queue_results.put(arg, timeout=0.05)
                        print(f'{self.name} sent {arg}')
                    except queue.Full:
                        pass
            except queue.Empty:
                pass

if __name__ == '__main__':
    for _ in range(100000000):
        with Multithreading(n_processes=2) as m:
            m.run()

我希望put和get方法的超时会引发相应的异常，但显然它们不会。

Answer 1

问题出在_Thread._run中：

def _run(self):
    print(f'Running {self.name}')
    while not self.event_stopped.is_set():             # Ok, loop until event_stopped
        try:
            arg = self.queue_inputs.get(timeout=0.05)  # Ok, try to get an item
            print(f'{self.name} received {arg}')
            while not self.event_stopped.is_set():     # Oops, what is this loop for???
                try:
                    self.queue_results.put(arg, timeout=0.05)
                    print(f'{self.name} sent {arg}')
                except queue.Full:
                    pass
        except queue.Empty:
            pass

您当前的代码在同一项目上无限循环（或直到其queue_results队列充满event_stopped被设置），重复将其添加到其 output 队列。 用if替换有问题的while足以解决问题：

    ...
    while not self.event_stopped.is_set():             # Ok, loop until event_stopped
        try:
            arg = self.queue_inputs.get(timeout=0.05)  # Ok, try to get an item
            print(f'{self.name} received {arg}')
            if not self.event_stopped.is_set():# ignore the item if stopped in the meanwhile
                try:
                    ...