你如何才能保护自己不受可能无限期挂起的程序库调用的影响？

Question

假设您发现自己处于依赖一个行为不佳的库的不幸境地。您的代码需要调用FlakyClient.call()，但有时该函数会挂起一段不可接受的时间。

如下所示，一种方法是将调用包装在自己的Process中，并使用join方法中的timeout参数来定义您愿意在FlakyClient上等待的最长时间。这提供了很好的保障，但也防止了代码的主体对调用FlakyClient.call()的结果做出反应。解决另一个问题(将结果输入代码的主体)的唯一方法是使用一些繁琐的IPC技术。

处理这两个问题的清洁和仿生方法是什么？如果库调用挂起，我希望保护自己，并且能够在调用完成时使用结果。

谢谢!

from multiprocessing import Process
from flaky.library import FlakyClient


TIMEOUT_IN_SECS = 10

def make_flaky_call():
    result = FlakyClient.call()

proc = Process(target=make_flaky_call)
proc.start()
proc.join(TIMEOUT_IN_SECS)
if proc.is_alive():
    proc.terminate()
    raise Exception("Timeout during call to FlakyClient.call().")

Answer 1

如果您正在使用流程，我建议您使用队列来处理结果传输，并间接地管理函数超时。

from multiprocessing import Process, Queue
from flaky.library import FlakyClient
import time

TIMEOUT_IN_SECS = 10

def make_flaky_call(queue):
    result = FlakyClient.call()
    queue.put(result)
    queue.put('END')

q = Queue()
proc = Process(target=make_flaky_call, args=(q,))
proc.start()
content = 0
result = None
while content != 'END':
    try:
        content = q.get(timeout=TIMEOUT_IN_SECS)
        if content != 'END':
            result = content
    except Empty:
        proc.terminate()
        raise Exception("Timeout during call to FlakyClient.call().")

Answer 2

我不能使用Python2.7，但是在Python3中，正确的处理方法是使用asyncio和期货的概念。

import concurrent

def make_flaky_call():
    return FlakyClient.call()

timeout = 10

with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
    future = executor.submit(make_flaky_call) # get a future object
    try:
        result = await future.result(timeout = timeout)
    except concurrent.futures.TimeOutError:
        # if a timeout occurs on the call, do something
        result = None # default value

这可是毕多诺。您可以将其与代码的主体集成起来。它正确地使用try-except进行错误处理。它有一个内置的超时。它只在Python3.5中工作(感谢await --但更改为yield from使其与Python3.4兼容)。

不幸的是，对于Python2.7来说，正确的处理方法是做您当前正在做的事情。