是否可以从 python 的子线程中杀死父线程？

Question

我在 Windows 上使用 Python 3.5.2。

我想运行一个 python 脚本，但保证不会超过 N 秒。如果 确实 花费了超过 N 秒，则应该引发异常，并且程序应该退出。最初我以为我可以在开始时启动一个线程，在抛出异常之前等待 N 秒，但这只会向计时器线程抛出异常，而不是向父线程抛出异常。例如：

import threading
import time

def may_take_a_long_time(name, wait_time):
    print("{} started...".format(name))
    time.sleep(wait_time)
    print("{} finished!.".format(name))

def kill():
    time.sleep(3)
    raise TimeoutError("No more time!")

kill_thread = threading.Thread(target=kill)
kill_thread.start()

may_take_a_long_time("A", 2)
may_take_a_long_time("B", 2)
may_take_a_long_time("C", 2)
may_take_a_long_time("D", 2)

这个输出：

A started...
A finished!.
B started...
Exception in thread Thread-1:
Traceback (most recent call last):
    File "C:\Program Files\Python35\lib\threading.py", line 914, in _bootstrap_inner
    self.run()
    File "C:\Program Files\Python35\lib\threading.py", line 862, in run
    self._target(*self._args, **self._kwargs)
    File "timeout.py", line 11, in kill
    raise TimeoutError("No more time!")
    TimeoutError: No more time!

B finished!.
C started...
C finished!.
D started...
D finished!.

这甚至是遥不可及的吗？我意识到我可以这样做：

import threading
import time

def may_take_a_long_time(name, wait_time, thread):
    if not thread.is_alive():
        return
    print("{} started...".format(name))
    time.sleep(wait_time)
    print("{} finished!.".format(name))

def kill():
    time.sleep(3)
    raise TimeoutError("No more time!")

kill_thread = threading.Thread(target=kill)
kill_thread.start()

may_take_a_long_time("A", 2, kill_thread)
may_take_a_long_time("B", 2, kill_thread)
may_take_a_long_time("C", 2, kill_thread)
may_take_a_long_time("D", 2, kill_thread)

但是，例如，如果调用了may_take_a_long_time("B", 60, kill_thread)，则此方法会失败。

所以我想我的 TL;DR 问题是，对主线程本身设置时间限制的最佳方法是什么？

Answer 1

你可以使用_thread.interrupt_main（这个模块在Python 2.7中被称为thread）：

import time, threading, _thread

def long_running():
    while True:
        print('Hello')

def stopper(sec):
    time.sleep(sec)
    print('Exiting...')
    _thread.interrupt_main()

threading.Thread(target = stopper, args = (2, )).start()

long_running()

Answer 2

如果父线程是根线程，可以试试os._exit(0)。

import os
import threading
import time

def may_take_a_long_time(name, wait_time):
    print("{} started...".format(name))
    time.sleep(wait_time)
    print("{} finished!.".format(name))

def kill():
    time.sleep(3)
    os._exit(0)

kill_thread = threading.Thread(target=kill)
kill_thread.start()

may_take_a_long_time("A", 2)
may_take_a_long_time("B", 2)
may_take_a_long_time("C", 2)
may_take_a_long_time("D", 2)

Answer 3

做到这一点的最干净的方法是有一个父线程定期检查的队列。如果孩子想要杀死父母，它会向队列发送一条消息（例如“DIE”）。父级检查队列，如果看到消息，它就会死掉。

    q = queue.Queue()
    bc = queue.Queue()          # backchannel

    def worker():
    while True:
            key = q.get()
            try:
                process_key(key)
            except ValueError as e:
                bc.put('DIE')
            q.task_done()

    # Start the threads
    for i in range(args.threads):
        threading.Thread(target=worker, daemon=True).start()

    for obj in object_farm():
        q.put(obj)
        try:
            back = bc.get(block=False)
        except queue.Empty:
            pass
        else:
            print("Data received on backchannel:",back)
            if back=='DIE':
                raise RuntimeError("time to die")