blocks|key|1784176|text|您需要将it转换为daemon+thread|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1784177|it+=+...
it.daemon+=+True
it.start()|code-block|syntax|javascript|1784178|否则，它将被创建为用户线程，并且在所有用户线程完成之前，该进程不会停止。|1784179|请注意，在您的实现中，即使在等待线程超时之后，线程仍将继续运行并消耗资源。CPython的Global+Interpreter+Lock可能会进一步加剧这个问题。|1784180|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/190010/daemon-threads-explanation|1|http://en.wikipedia.org/wiki/Global_Interpreter_Lock^0|4|2|9|D|0|0|0|0|19|N|1|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@$9|11|A|12|1|13]]|E|$]]|$1|F|3|G|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|15|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|16|8|@]|D|@$9|17|A|18|1|19]]|E|$]]|$1|O|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]|W|$5|R|S|T|E|$U|X]]]]

You need to turn <code>it</code> into a <a href="https://stackoverflow.com/questions/190010/daemon-threads-explanation">daemon thread</a>:

<pre><code>it = ...
it.daemon = True
it.start()
</code></pre>

Otherwise it's created as a user thread, and the process won't get stopped until all the user threads have finished.

Note that with your implementation the thread will continue to run and consume resources even after you've timed out waiting for it. CPython's <a href="http://en.wikipedia.org/wiki/Global_Interpreter_Lock" rel="nofollow noreferrer">Global Interpreter Lock</a> could exacerbate the issue further.

blocks|key|1784231|text|一个线程不能优雅地终止另一个线程，所以使用您当前的代码，foo永远不会终止。(使用thread.daemon+=+True，Python程序将在只剩下守护线程时退出，但这不允许您在不终止主线程的情况下终止foo。)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1784232|Some+people曾试图使用信号停止执行，但在某些情况下这可能是unsafe。|1784233|如果您可以修改foo，则有许多可能的解决方案。例如，您可以检查一个threading.Event以跳出while循环。|1784234|但是，如果您不能修改foo，您可以使用multiprocessing模块在子进程中运行它，因为与线程不同，子进程可以终止。下面是一个示例，说明了它可能是什么样子：|1784235|import+time
import+multiprocessing+as+mp

def+foo(x+=+1):
++++cnt+=+1
++++while+True:
++++++++time.sleep(1)
++++++++print(x,+cnt)
++++++++cnt+%2B=+1

def+timeout(func,+args+=+(),+kwds+=+{},+timeout+=+1,+default+=+None):
++++pool+=+mp.Pool(processes+=+1)
++++result+=+pool.apply_async(func,+args+=+args,+kwds+=+kwds)
++++try:
++++++++val+=+result.get(timeout+=+timeout)
++++except+mp.TimeoutError:
++++++++pool.terminate()
++++++++return+default
++++else:
++++++++pool.close()
++++++++pool.join()
++++++++return+val


if+__name__+==+'__main__':
++++print(timeout(foo,+kwds+=+{'x':+'Hi'},+timeout+=+3,+default+=+'Bye'))
++++print(timeout(foo,+args+=+(2,),+timeout+=+2,+default+=+'Sayonara'))|code-block|syntax|javascript|1784236|收益率|1784237|('Hi',+1)
('Hi',+2)
('Hi',+3)
Bye
(2,+1)
(2,+2)
Sayonara|1784238|请注意，这也有一些限制。|1784239|1784240|subprocesses接收父进程变量的副本。如果您修改子流程中的变量，则不会影响父流程。如果您的函数func需要修改变量，您将需要使用shared+variable.|unordered-list-item|1784241|arguments+(通过args传递)，并且关键字(kwds)必须是线程，它们比线程更消耗资源。通常，您只想在程序开始时创建一次多进程池。此timeout函数在您每次调用它时都会创建一个Pool。这是必要的，因为我们需要pool.terminate()来终止foo。也许还有更好的办法，但我还没想到。--|1784242|1784243|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/q/366682/190597|1|https://stackoverflow.com/a/1114567/190597|2|http://docs.python.org/2/library/multiprocessing.html#sharing-state-between-processes^0|S|3|15|K|2U|3|0|0|B|0|Y|6|1|0|7|3|X|F|0|A|3|J|F|0|0|0|0|0|0|1F|4|1W|F|2|0|D|4|R|4|1Z|7|2M|4|33|G|3M|3|0|0^^$0|@$1|2|3|4|5|6|7|1F|8|@$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1M|8|@]|D|@$9|1N|A|1O|1|1P]|$9|1Q|A|1R|1|1S]]|E|$]]|$1|H|3|I|5|6|7|1T|8|@$9|1U|A|1V|B|C]|$9|1W|A|1X|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|1Y|8|@$9|1Z|A|20|B|C]|$9|21|A|22|B|C]]|D|@]|E|$]]|$1|L|3|M|5|N|7|23|8|@]|D|@]|E|$O|P]]|$1|Q|3|R|5|6|7|24|8|@]|D|@]|E|$]]|$1|S|3|T|5|N|7|25|8|@]|D|@]|E|$O|P]]|$1|U|3|V|5|6|7|26|8|@]|D|@]|E|$]]|$1|W|3|-4|5|6|7|27|8|@]|D|@]|E|$]]|$1|X|3|Y|5|Z|7|28|8|@$9|29|A|2A|B|C]]|D|@$9|2B|A|2C|1|2D]]|E|$]]|$1|10|3|11|5|Z|7|2E|8|@$9|2F|A|2G|B|C]|$9|2H|A|2I|B|C]|$9|2J|A|2K|B|C]|$9|2L|A|2M|B|C]|$9|2N|A|2O|B|C]|$9|2P|A|2Q|B|C]]|D|@]|E|$]]|$1|12|3|-4|5|6|7|2R|8|@]|D|@]|E|$]]|$1|13|3|-4|5|6|7|2S|8|@]|D|@]|E|$]]]|14|$15|$5|16|17|18|E|$19|1A]]|1B|$5|16|17|18|E|$19|1C]]|1D|$5|16|17|18|E|$19|1E]]]]

A thread can not gracefully kill another thread, so with your current code, <code>foo</code> never terminates. (With <code>thread.daemon = True</code> the Python program will exit when only daemon threads are left, but that does not allow you to terminate <code>foo</code> without also terminating the main thread.)

<a href="https://stackoverflow.com/q/366682/190597">Some people</a> have tried to use signals to halt execution, but this may be <a href="https://stackoverflow.com/a/1114567/190597">unsafe</a> in some cases.

If you can modify <code>foo</code>, there are many solutions possible. For instance, you could check for a <code>threading.Event</code> to break out of the while-loop. 

But if you can not modify <code>foo</code>, you could run it in a subprocess using the <code>multiprocessing</code> module since unlike threads, subprocesses can be terminated. Here is an example of how that might look:

<pre><code>import time
import multiprocessing as mp

def foo(x = 1):
 cnt = 1
 while True:
 time.sleep(1)
 print(x, cnt)
 cnt += 1

def timeout(func, args = (), kwds = {}, timeout = 1, default = None):
 pool = mp.Pool(processes = 1)
 result = pool.apply_async(func, args = args, kwds = kwds)
 try:
 val = result.get(timeout = timeout)
 except mp.TimeoutError:
 pool.terminate()
 return default
 else:
 pool.close()
 pool.join()
 return val


if __name__ == '__main__':
 print(timeout(foo, kwds = {'x': 'Hi'}, timeout = 3, default = 'Bye'))
 print(timeout(foo, args = (2,), timeout = 2, default = 'Sayonara'))
</code></pre>

yields

<pre><code>('Hi', 1)
('Hi', 2)
('Hi', 3)
Bye
(2, 1)
(2, 2)
Sayonara
</code></pre>

Note that this has some limitations too. 

<ul>
<li>subprocesses receive a copy of the parent processes' variables. If you modify a variable in a subprocess, it will NOT affect
the parent process. If your function <code>func</code> needs to modify variables, you will need to use a <a href="http://docs.python.org/2/library/multiprocessing.html#sharing-state-between-processes" rel="noreferrer">shared variable</a>.</li>
<li>arguments (passed through <code>args</code>) and keywords (<code>kwds</code>) must be
picklable.</li>
<li>processes are more resource-heavy than threads. Usually, you only
want to create a multiprocessing Pool once at the beginning of a
program. This <code>timeout</code> function creates a <code>Pool</code> every time you call it. This was necessary since we needed <code>pool.terminate()</code> to
terminate <code>foo</code>. There might be a better way, but I haven't thought of it.</li>
</ul>

blocks|key|1784267|text|使用multiprocessing的好处是进程不共享内存，子进程中发生的任何事情都仅限于该函数，不会导致其他进程终止。将子进程的超时时间添加到3s的最简单方法是：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1784268|import+multiprocessing

def+my_child():
++++function+here

process+=+multiprocessing.Process(target=my_child)
process.daemon+=+True
process.start()

process.join(3)
if+process.is_alive():
++++process.terminate()|code-block|syntax|javascript|1784269|entityMap^0|2|F|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

The benefit of using <code>multiprocessing</code> is the processes do not share memory and whatever happens in the child remains limited to that function and will not cause other process to terminate. The easiest way to add a timeout of 3s to a child process is:
<pre><code>import multiprocessing

def my_child():
 function here

process = multiprocessing.Process(target=my_child)
process.daemon = True
process.start()

process.join(3)
if process.is_alive():
 process.terminate()
</code></pre>

I have found a code creating a timeout function <a href="http://code.activestate.com/recipes/473878-timeout-function-using-threading/" rel="noreferrer">here</a>, which does not seem to work. The complete test code is below:

<pre><code>def timeout(func, args=(), kwargs={}, timeout_duration=1, default=None):
 import threading
 class InterruptableThread(threading.Thread):
 def __init__(self):
 threading.Thread.__init__(self)
 self.result = None

 def run(self):
 try:
 self.result = func(*args, **kwargs)
 except:
 self.result = default

 it = InterruptableThread()
 it.start()
 it.join(timeout_duration)
 if it.isAlive():
 return default
 else:
 return it.result


def foo():
 while True:
 pass

timeout(foo,timeout_duration=3)
</code></pre>

Expected behavior: code ends within 3 seconds. Where is the problem?

Timeout function using threading in python does not work

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我发现了一个创建超时函数的代码，它似乎不起作用。完整的测试代码如下：def timeout(func, args=(), kwargs={}, timeout_duration=1, default=None):    import threading    class InterruptableThread(thre...

问在python中使用线程的超时函数不起作用
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在python中使用线程的超时函数不起作用EN