大多数Pythonic方式在一段时间后杀死一个线程

Question

我想在一个线程中运行一个进程(它在一个大型数据库表上进行迭代).线程正在运行时,我只想让程序等待.如果该线程花费的时间超过30秒,我想杀死该线程并执行其他操作.通过杀死线程,我的意思是我希望它停止活动并优雅地释放资源.

我想这样做是通过最好的方式Thread()的join(delay)和is_alive()功能,以及Event.使用join(delay)我可以让我的程序等待30秒以完成线程,并通过使用该is_alive()函数我可以确定线程是否已完成其工作.如果它尚未完成其工作,则设置该事件,并且线程知道在该点停止工作.

这种方法是否有效,这是解决我的问题陈述的最pythonic方式吗？

以下是一些示例代码:

import threading
import time

# The worker loops for about 1 minute adding numbers to a set
# unless the event is set, at which point it breaks the loop and terminates
def worker(e):
    data = set()
    for i in range(60):
        data.add(i)
        if not e.isSet():
            print "foo"
            time.sleep(1)
        else:
            print "bar"
            break

e = threading.Event()
t = threading.Thread(target=worker, args=(e,))
t.start()

# wait 30 seconds for the thread to finish its work
t.join(30)
if t.is_alive():
    print "thread is not done, setting event to kill thread."
    e.set()
else:
    print "thread has already finished."

Answer 1

我玩这个游戏已经很晚了，但我一直在努力解决类似的问题，以下内容似乎既可以完美地解决我的问题，又可以让我在守护子线程退出时进行一些基本的线程状态检查和清理：

import threading
import time
import atexit

def do_work():

  i = 0
  @atexit.register
  def goodbye():
    print ("'CLEANLY' kill sub-thread with value: %s [THREAD: %s]" %
           (i, threading.currentThread().ident))

  while True:
    print i
    i += 1
    time.sleep(1)

t = threading.Thread(target=do_work)
t.daemon = True
t.start()

def after_timeout():
  print "KILL MAIN THREAD: %s" % threading.currentThread().ident
  raise SystemExit

threading.Timer(2, after_timeout).start()

产量：

0
1
KILL MAIN THREAD: 140013208254208
'CLEANLY' kill sub-thread with value: 2 [THREAD: 140013674317568]

Answer 2

在这种情况下使用事件可以很好地作为信令机制,并且实际上在线程模块文档中推荐使用.

如果您希望线程正常停止,请使它们成为非守护进程并使用合适的信令机制,例如Event.

验证线程终止时,超时几乎总是会引入错误空间.因此,虽然使用.join()带有超时的初始决策来触发事件是正常的,但最终验证应该使用 .join()没有超时的情况.

# wait 30 seconds for the thread to finish its work
t.join(30)
if t.is_alive():
    print "thread is not done, setting event to kill thread."
    e.set()
    # The thread can still be running at this point. For example, if the 
    # thread's call to isSet() returns right before this call to set(), then
    # the thread will still perform the full 1 second sleep and the rest of 
    # the loop before finally stopping.
else:
    print "thread has already finished."

# Thread can still be alive at this point. Do another join without a timeout 
# to verify thread shutdown.
t.join()

这可以简化为这样的:

# Wait for at most 30 seconds for the thread to complete.
t.join(30)

# Always signal the event. Whether the thread has already finished or not, 
# the result will be the same.
e.set()

# Now join without a timeout knowing that the thread is either already 
# finished or will finish "soon."
t.join()