python程序超时处理方式

import time
import timeout_decorator
@timeout_decorator.timeout(6)
def justtest():
    time.sleep(5)
    return 5
aaa = justtest()
print aaa

import time
import timeout_decorator
@timeout_decorator.timeout(3)
def justtest():
    time.sleep(5)
    return 5
aaa = justtest()
print aaa

pip install eventlet

import time
import eventlet                     # 导入eventlet模块
eventlet.monkey_patch()             # 引入patch
with eventlet.Timeout(3, False):    # 设置超时时间3秒
    time.sleep(4)                   # 等待4秒
    print('结果1')                   # 因为等待了4秒，大于超时时间，所以'结果1‘不打印
print('结果2')
# 运行以上程序输出：
# 结果2
with eventlet.Timeout(3, False):    # 设置超时时间3秒
    time.sleep(2)                   # 等待2秒
    print('结果3')                   # 因为等待了2秒，小于超时时间，所以'结果3‘也会打印
print('结果4')
# 运行以上程序输出：
# 结果3
# 结果4

import time
import os
import eventlet                     # 导入eventlet模块
from multiprocessing import Process
def my_test(name):
    print('子进程运行中，name={}，pid={}'.format(name, os.getpid()))
    time.sleep(10)
    print('子进程已经结束')
if __name__ == '__main__':
    eventlet.monkey_patch()                                 # 引入patch
    with eventlet.Timeout(3, False):                        # 这里设置了超时时间3
        print('父进程：{}'.format(os.getpid()))
        p = Process(target=my_test, args=('test', ))        # 调用了子进程，子进程内有等待10秒的步骤，等待完才会打印'子进程已经结束‘
        print('子进程准备执行---')
        p.start()
# 执行以上程序输出：
# 父进程：11548
# 子进程准备执行 - --
# 子进程运行中，name = test，pid = 1996
# 子进程已经结束

def my_test(name):
    print('子进程运行中，name={}，pid={}'.format(name, os.getpid()))
    eventlet.monkey_patch()                                 # 引入patch
    with eventlet.Timeout(3, False):
        time.sleep(10)
        print('等待时间结束')
    print('子进程已经结束')

pip install func-timeout

# func_set_timeout作为装饰器使用，来作为目标函数的超时处理方式
import time
import os
from func_timeout import func_set_timeout
@func_set_timeout(5)
def my_test(name):
    print('子进程运行中，name={}，pid={}'.format(name, os.getpid()))
    time.sleep(4)			
    print('子进程已经结束')
if __name__ == '__main__':
    print('父进程：{}'.format(os.getpid()))
    try:
        p = Process(target=my_test, args=('test', ))
        p.start()
    except TimeoutError as e:
        print('子程序超时')
# 执行以上程序输出：
# 父进程：29908
# 结束
# 子进程运行中，name=test，pid=40280
# 子进程已经结束
# 说明：my_test函数执行需要4s，设置的超时时间大于4s，因此子进程正常执行；若设置my_test函数执行时间大于5s，则报错，代码中尝试了通过捕获异常来让程序正常运行退出，但超时异常时发生在子进程中的，因此捕获异常失败，此时的报错见图1。

import time
import os
from func_timeout import func_timeout
from func_timeout import FunctionTimedOut
def my_test(name):
    print('进程运行中，name={}，pid={}'.format(name, os.getpid()))
    time.sleep(6)
    print('进程已经结束')
if __name__ == '__main__':
    try:
        func_timeout(3, my_test, args=('test', ))
    except FunctionTimedOut as e:
        print(e)
        print('进程运行超时')
# 输出：
# 进程运行中，name=test，pid=3364
# Function my_test (args=('test',)) (kwargs={}) timed out # after 3.000000 seconds.
# 进程运行超时
# 说明：func_timeout()第一个参数为超时时间，第二个参数是调用的函数，注意这里只调用函数名，没有(), 第三个参数是调用函数的参数。这里使用的异常捕获也不能解决2.1中的报错问题。