python - 线程已完成的进程永远不会退出

Question

为什么线程应该持续存在并阻止其进程退出，即使在其目标完成之后也是如此？

While this question uses an additional child-process, the underlaying issue is entirely rooted in multithreading. Therefore this basic issue can be reproduced with the MainProcess alone. (Edited by @Darkonaut)

我创建了一个继承multiprocessing.Process的类:

class Task(Process):
    def run(self) :
        print("RUN")

        t = threading.Thread(target=do_some_work)
        t.start()
        # ...
        t.join()
        print("CLOSED")

我是这样开始的:

proc = Task()
proc.start()
proc.join()
print("JOINED")

但是它不会加入，输出将是这样的:

>> RUN
>> CLOSED

我没有使用任何类型的队列和管道。

当我在 Ubuntu 上运行这个程序时，我用它的 pid 跟踪了该进程。即使在 print("CLOSED") 行完成后，该进程仍然存在，没有任何异常。我还在 Windows 上运行了这个程序并在任务管理器中跟踪了该过程。进程在 print("CLOSED") 后退出，但仍未加入。

另一点是，在 Ubuntu 上，当 print("CLOSED") 之后一切都卡住并且我按 Ctrl + C 时，我得到:

Traceback (most recent call last):
  File "Scheduler.py", line 164, in <module>
    scheduler.start()
  File "Scheduler.py", line 152, in start
    self.enqueueTask(plan)
  File "Scheduler.py", line 134, in enqueueTask
    proc.join()
  File "/usr/local/lib/python3.8/multiprocessing/process.py", line 149, in join
    res = self._popen.wait(timeout)
  File "/usr/local/lib/python3.8/multiprocessing/popen_fork.py", line 47, in wait
    return self.poll(os.WNOHANG if timeout == 0.0 else 0)
  File "/usr/local/lib/python3.8/multiprocessing/popen_fork.py", line 27, in poll
    pid, sts = os.waitpid(self.pid, flag)

根据最后一行，我猜主进程正在等待某些东西，但是什么以及为什么？

问题似乎出在我在 Task 的 run() 方法中启动的非守护线程。 使该线程成为守护线程可以解决问题，因此我可以肯定地说，即使在其 MainThread 完成后，该线程也会阻止我的进程关闭。我仍然很困惑，因为该非守护线程的目标函数已成功完成。

Answer 1

Why should a thread persist and prevent its process to exit, even after its target is done?

虽然这个问题使用了额外的子进程，但底层问题完全源于多线程。因此，这个基本问题可以通过 MainProcess 重现。独自的。涉及额外子进程的答案可以在 edit 2 中找到。 .

<小时/>

场景

在没有看到子进程中的新线程真正在做什么的情况下，您观察到的行为的可能情况是您的 thread-1正在开始又一个 thread-2 ，你甚至可能不知道。可能它是从您正在调用的第三方库启动的，或者保留在 stdlib 中，multiprocessing.Queue.put()还在后台启动一个供给线程。

这个一般场景不是 Process -子类化问题与调用Process.close()无关来自子进程本身(不正确的使用，但没有后果)。

MainThread进程中始终是退出进程中的最后一个线程，并且它正在加入非守护线程作为其 _shutdown() 的一部分-常规。这就是保持 MainThread 的原因。处于不确定状态，而其“表面”工作已经完成。

The problem is with a non-daemon thread that I'm starting in run() method of Task. so I can surely say that thread is preventing my process to be closed even after its MainThread is done. but I'm still confused because target function of that non-daemon thread is done successfully.

现在，在如图所示的场景中，您的目标函数为 thread-1 实际上可以成功完成。然而这个thread-1已开始另一个thread-2 ，然后它会执行一些持续很长时间的操作，例如在最坏的情况下永远阻塞。

Q: If thread-1 itself is not the problem, why there is no hanging when you make thread-1 a daemon?

这是因为守护进程标志的 "initial value is inherited from the creating thread" 。所以制作thread-1一个daemon ，使其后代 thread-2一个daemon也是如此，除非daemon -标志 thread-2被明确设置。守护进程在关闭时不会加入，整个过程“当没有剩余的事件非守护线程时退出”。

请注意，在 Python 3.7 之前，由 Process 创建的非守护线程尚未加入。MainProcess 之外的线程的这种不同行为已修复于 bpo-18966 .

<小时/>

代码

为了表明这种情况已经可以通过更简单的设置重现，下面的示例使用 MainProcess作为不会退出的进程。 thread-2这是 Timer -thread，它将启动并调用 threading.Barrier(parties=1).wait() 10秒后。这个.wait()然后调用将立即结束 parties=1 ，或使用 parties=2 永远阻止因为没有其他人调用.wait()关于这个 Barrier 存在于我们的设置中。这使得我们能够轻松切换我们想要重现的行为。

import threading

def blackbox(parties):
    """Dummy for starting thread we might not know about."""
    timer = threading.Timer(10, threading.Barrier(parties=parties).wait)  # Thread-2
    timer.name = "TimerThread"
    timer.start()


def t1_target(parties):  # Thread-1
    """Start another thread and exit without joining."""
    logger = get_mp_logger()
    logger.info(f"ALIVE: {[t.name for t in threading.enumerate()]}")
    blackbox(parties)
    logger.info(f"ALIVE: {[t.name for t in threading.enumerate()]}")
    logger.info("DONE")


if __name__ == '__main__':

    import logging

    parties = 1
    daemon = False
    print(f"parties={parties}, daemon={daemon}")

    logger = get_mp_logger(logging.INFO)
    logger.info(f"ALIVE: {[t.name for t in threading.enumerate()]}")
    t = threading.Thread(target=t1_target, args=(parties,), daemon=daemon)
    t.start()
    t.join()
    logger.info(f"ALIVE: {[t.name for t in threading.enumerate()]}")    
    logger.info("DONE")

下面的日志适用于parties=1 ，所以不存在无限阻塞，但是因为 thread-2不是守护线程，MainThread将在关机时加入它。请注意TimerThread t1_target之后仍然活着已经完成了。这里主要感兴趣的是 MainThread 如何从 "DONE" 需要大约 10 秒至"process shutting down" 。这是 10 秒 TimerThread还活着。

parties=1, daemon=False
[18:04:31,977 MainThread <module>] ALIVE: ['MainThread']
[18:04:31,977 Thread-1 t1_target] ALIVE: ['MainThread', 'Thread-1']
[18:04:31,978 Thread-1 t1_target] ALIVE: ['MainThread', 'Thread-1', 'TimerThread']
[18:04:31,978 Thread-1 t1_target] DONE
[18:04:31,978 MainThread <module>] ALIVE: ['MainThread', 'TimerThread']
[18:04:31,978 MainThread <module>] DONE
[18:04:41,978 MainThread info] process shutting down

Process finished with exit code 0

与 parties=2它在这个阶段永远挂起，...

parties=2, daemon=False
[18:05:06,010 MainThread <module>] ALIVE: ['MainThread']
[18:05:06,010 Thread-1 t1_target] ALIVE: ['MainThread', 'Thread-1']
[18:05:06,011 Thread-1 t1_target] ALIVE: ['MainThread', 'Thread-1', 'TimerThread']
[18:05:06,011 Thread-1 t1_target] DONE
[18:05:06,011 MainThread <module>] ALIVE: ['MainThread', 'TimerThread']
[18:05:06,011 MainThread <module>] DONE

...除非您还设置了 daemon=True ，或者 thread-1 ( thread-2 继承)或仅用于 thread-2直接。

parties=2, daemon=True
[18:05:35,539 MainThread <module>] ALIVE: ['MainThread']
[18:05:35,539 Thread-1 t1_target] ALIVE: ['MainThread', 'Thread-1']
[18:05:35,539 Thread-1 t1_target] ALIVE: ['MainThread', 'Thread-1', 'TimerThread']
[18:05:35,539 Thread-1 t1_target] DONE
[18:05:35,539 MainThread <module>] ALIVE: ['MainThread', 'TimerThread']
[18:05:35,539 MainThread <module>] DONE
[18:05:35,539 MainThread info] process shutting down

Process finished with exit code 0

<小时/>

helper

DEFAULT_MP_FORMAT = \
    '[%(asctime)s,%(msecs)03d %(threadName)s %(funcName)s]' \
    ' %(message)s'
DEFAULT_DATEFORMAT = "%H:%M:%S"  # "%Y-%m-%d %H:%M:%S"


def get_mp_logger(level=None, fmt=DEFAULT_MP_FORMAT, datefmt=DEFAULT_DATEFORMAT):
    """
    Initialize multiprocessing-logger if needed and return reference.
    """
    import multiprocessing.util as util
    import logging
    logger = util.get_logger()
    if not logger.handlers:
        logger = util.log_to_stderr(level)
    logger.handlers[0].setFormatter(logging.Formatter(fmt, datefmt))
    return logger