stopit 1.1.2

stopit.async_raise

在另一个线程中引发任意异常的函数

async_raise(tid, exception)

• tid是线程标识符，由线程对象的ident属性提供。有关更多信息，请参阅threading模块的文档。

• exception是要在线程中引发的异常类或对象。

stopit.ThreadingTimeout

一个“杀死”其内部块执行超过提供时间的上下文管理器。

ThreadingTimeout(seconds, swallow_exc=True)

• seconds是上下文管理块执行允许的秒数。

• swallow_exc：如果为False，则在退出上下文管理块时将重新引发可能的stopit.TimeoutException。注意：值为True不会吞下其他潜在的异常。

方法和属性

属于stopit.ThreadingTimeout上下文管理器的。

典型用法

import stopit
# ...
with stopit.ThreadingTimeout(10) as to_ctx_mgr:
    assert to_ctx_mgr.state == to_ctx_mgr.EXECUTING
    # Something potentially very long but which
    # ...

# OK, let's check what happened
if to_ctx_mgr.state == to_ctx_mgr.EXECUTED:
    # All's fine, everything was executed within 10 seconds
elif to_ctx_mgr.state == to_ctx_mgr.EXECUTING:
    # Hmm, that's not possible outside the block
elif to_ctx_mgr.state == to_ctx_mgr.TIMED_OUT:
    # Eeek the 10 seconds timeout occurred while executing the block
elif to_ctx_mgr.state == to_ctx_mgr.INTERRUPTED:
    # Oh you raised specifically the TimeoutException in the block
elif to_ctx_mgr.state == to_ctx_mgr.CANCELED:
    # Oh you called to_ctx_mgr.cancel() method within the block but it
    # executed till the end
else:
    # That's not possible

请注意，上下文管理器对象可以被视为一个布尔值，表示（如果True）块已正常执行

if to_ctx_mgr:
    # Yes, the code under timeout control completed
    # Objects it created or changed may be considered consistent

stopit.threading_timeoutable

一个装饰器，如果被装饰的函数或方法在给定的时间框架内没有返回，则会将其终止。

stopit.threading_timeoutable([default [, timeout_param]])

• default 是当被装饰的函数或方法执行超时时应返回的值，以通知调用代码该函数未在分配的时间框架内完成。

  如果未提供此参数，则被装饰的函数或方法在执行超时时将返回一个 None 值。

  @stopit.threading_timeoutable(default='not finished')
  def infinite_loop():
      # As its name says...
  
  result = infinite_loop(timeout=5)
  assert result == 'not finished'

• timeout_param：您装饰的函数或方法可能需要以任何原因命名的 timeout 参数。这使您能够将装饰函数签名中的 timeout 参数名称更改为任何适合的名称，并防止潜在的命名冲突。

  @stopit.threading_timeoutable(timeout_param='my_timeout')
  def some_slow_function(a, b, timeout='whatever'):
      # As its name says...
  
  result = some_slow_function(1, 2, timeout="something", my_timeout=2)

关于装饰函数

或方法…

如您所注意到的，您只需在调用函数或方法时添加 timeout 参数。或者使用装饰器的 timeout_param 选择的其他名称。在调用实际的内部函数或方法时，此参数将被删除。

吞咽超时异常

我们检查快速函数在上下文管理器外部返回

>>> with Timeout(5.0) as timeout_ctx:
...     result = fast_func()
>>> result
0
>>> timeout_ctx.state == timeout_ctx.EXECUTED
True

并且上下文管理器被认为是 True（块执行了其最后一行）

>>> bool(timeout_ctx)
True

我们检查慢速函数被中断

>>> start_time = time.time()
>>> with Timeout(2.0) as timeout_ctx:
...     variable_duration_func(5.0)
>>> time.time() - start_time < 2.2
True
>>> timeout_ctx.state == timeout_ctx.TIMED_OUT
True

并且由于块超时，上下文管理器被认为是 False

>>> bool(timeout_ctx)
False

其他异常会被传播，必须像通常一样处理

>>> try:
...     with Timeout(5.0) as timeout_ctx:
...         result = func_with_exception()
... except LookupError:
...     result = 'exception_seen'
>>> timeout_ctx.state == timeout_ctx.EXECUTING
True
>>> result
'exception_seen'

传播TimeoutException

我们还可以选择传播 TimeoutException。必须处理潜在异常

>>> result = None
>>> start_time = time.time()
>>> try:
...     with Timeout(2.0, swallow_exc=False) as timeout_ctx:
...         variable_duration_func(5.0)
... except TimeoutException:
...     result = 'exception_seen'
>>> time.time() - start_time < 2.2
True
>>> result
'exception_seen'
>>> timeout_ctx.state == timeout_ctx.TIMED_OUT
True

还必须处理其他异常

>>> result = None
>>> start_time = time.time()
>>> try:
...     with Timeout(2.0, swallow_exc=False) as timeout_ctx:
...         func_with_exception()
... except Exception:
...     result = 'exception_seen'
>>> time.time() - start_time < 0.1
True
>>> result
'exception_seen'
>>> timeout_ctx.state == timeout_ctx.EXECUTING
True