<p>虽然<code>socket.setsocketimeout</code>将为新套接字设置默认超时,但如果不直接使用套接字,则很容易覆盖该设置。特别是,如果库在其套接字上调用<code>socket.setblocking</code>,它将重置超时。</p>
<p><code>urllib2.open</code>有一个超时参数,hoviewer,<code>urllib2.Request</code>中没有超时。在使用<code>mechanize</code>时,应参考他们的文档:</p>
<blockquote>
<p>Since Python 2.6, urllib2 uses a .timeout attribute on Request objects internally. However, urllib2.Request has no timeout constructor argument, and urllib2.urlopen() ignores this parameter. mechanize.Request has a timeout constructor argument which is used to set the attribute of the same name, and mechanize.urlopen() does not ignore the timeout attribute.</p>
</blockquote>
<p><em>来源:<a href="http://wwwsearch.sourceforge.net/mechanize/documentation.html" rel="noreferrer">http://wwwsearch.sourceforge.net/mechanize/documentation.html</a></em></p>
<p><strong>---编辑---</strong></p>
<p>如果<code>socket.setsockettimeout</code>或将超时传递给<code>mechanize</code>的值很小,但不是更高,则问题的根源可能完全不同。一件事是你的库可能会打开多个连接(这里归功于@Cédric Julien),因此超时适用于socket.open的每次尝试,如果它没有在第一次失败时停止,则可能需要长达<code>timeout * num_of_conn</code>秒的时间。另一件事是<code>socket.recv</code>:如果连接真的很慢,而且你够不走运,那么整个请求可能需要<code>timeout * incoming_bytes</code>的时间,就像每个<code>socket.recv</code>我们可以得到一个字节一样,每个这样的调用可能需要<code>timeout</code>秒。因为您不太可能遭受这种黑暗场景的影响(每超时秒一个字节?你必须是一个非常粗鲁的男孩),这很可能要求花很长时间非常慢的连接和非常高的超时。</p>
<p>唯一的解决方案是强制整个请求超时,但这里与套接字无关。如果您在Unix上,可以使用带有<code>ALARM</code>信号的简单解决方案。您将信号设置为在<code>timeout</code>秒内发出,您的请求将被终止(不要忘记捕获它)。您可能希望使用<code>with</code>语句使其干净且易于使用,例如:</p>
<pre><code>import signal, time
def request(arg):
"""Your http request"""
time.sleep(2)
return arg
class Timeout():
"""Timeout class using ALARM signal"""
class Timeout(Exception): pass
def __init__(self, sec):
self.sec = sec
def __enter__(self):
signal.signal(signal.SIGALRM, self.raise_timeout)
signal.alarm(self.sec)
def __exit__(self, *args):
signal.alarm(0) # disable alarm
def raise_timeout(self, *args):
raise Timeout.Timeout()
# Run block of code with timeouts
try:
with Timeout(3):
print request("Request 1")
with Timeout(1):
print request("Request 2")
except Timeout.Timeout:
print "Timeout"
# Prints "Request 1" and "Timeout"
</code></pre>
<p>如果想要比这更便携,您必须使用一些更大的枪,例如<code>multiprocessing</code>,因此您将生成一个进程来调用您的请求,并在过期时终止它。由于这是一个单独的过程,您必须使用一些东西将结果传输回您的应用程序,它可能是<code>multiprocessing.Pipe</code>。下面是一个例子:</p>
<pre><code>from multiprocessing import Process, Pipe
import time
def request(sleep, result):
"""Your http request example"""
time.sleep(sleep)
return result
class TimeoutWrapper():
"""Timeout wrapper using separate process"""
def __init__(self, func, timeout):
self.func = func
self.timeout = timeout
def __call__(self, *args, **kargs):
"""Run func with timeout"""
def pmain(pipe, func, args, kargs):
"""Function to be called in separate process"""
result = func(*args, **kargs) # call func with passed arguments
pipe.send(result) # send result to pipe
parent_pipe, child_pipe = Pipe() # Pipe for retrieving result of func
p = Process(target=pmain, args=(child_pipe, self.func, args, kargs))
p.start()
p.join(self.timeout) # wait for prcoess to end
if p.is_alive():
p.terminate() # Timeout, kill
return None # or raise exception if None is acceptable result
else:
return parent_pipe.recv() # OK, get result
print TimeoutWrapper(request, 3)(1, "OK") # prints OK
print TimeoutWrapper(request, 1)(2, "Timeout") # prints None
</code></pre>
<p>如果你想强制请求在固定的秒数后终止,你真的没有太多选择。<code>socket.timeout</code>将为单个套接字操作(connect/recv/send)提供超时,但如果有多个套接字操作,则可能会导致执行时间过长。</p>