python multiprocessing进程超时处理与进度条显示的平衡

最近写python项目，遇到几个多进程的问题

多进程情况下，如何显示总任务的运行进度

用的比较多的是tqdm库，使用非常方便，在有迭代的地方加上tqdm即可。

比如使用Pool.imap()执行任务时

from multiprocessing import Pool
with Pool(4) as p:
	res = list(tqdm(p.imap(function_name, params), total=len(params)))
p.close()
p.join()

或者通过for循环执行任务时

from multiprocessing import Pool
pool = Pool(processes=4)
for i  in tqdm(range(500)):
    pool.apply(test, args=(i,))   
pool.close()
pool.join()

我的项目中需要对大量的url进行请求和处理，所以经常会出现某个进程的请求长时间没有响应而被挂起的情况，导致tqdm经常会卡在99%或100%处无法结束。tqdm本身似乎也没有超时机制，所以在利用多进程处理爬虫这类需要进程等待结果的任务时，必须要添加子进程的超时机制。

多进程的超时处理

我研究了一下进程池超时处理的几个办法。比较主流的有以下几种：

1. get获取多进程的返回值，获取超时则抛出异常
2. 在需要执行的任务函数中添加计时器和时间，超时抛出异常
3. 为每个任务进程添加守护进程，由守护进程计算执行的时间，如果超时则守护进程杀死任务进程

多进程超时与总进度条的显示

将多进程超时处理与进度条处理结合了一下

• 方法一
  使用map_async处理任务，通过get超时判断进程超时。这个方法实现比较简单，但是运行起来非常的慢。

pool = Pool(processes=4)
for l in tqdm(links,total=1000): # total为links的总数
    r = pool.map_async(self.check,(l,))
    try:
        print(r.get(timeout=3)) # 设置子进程的响应超时为3s
    except multiprocessing.context.TimeoutError:
        pass

• 方法二
  使用imap_unordered()执行任务，进程执行的结果会在进程执行完后就立刻返回，不像map()需要等待所有任务执行完一次性返回结果。这里可以通过next迭代获取该函数所有进程的下的返回值，当获取超时，则抛出超时异常。但是测试发现，如果进程返回超时，.next会重复获取超时进程的返回结果，重复抛出超时异常，而不是在抛出超时异常后执行下一个任务，也相当于是挂起状态了，并没有解决进程超时的问题。看了一下imap_unordered()的源代码，发现next的逻辑是在没有获取到数据之前，会一直重复请求直到取到数据为止。不知道是不是还有别的隐藏技能，总觉得这个逻辑设计的怪怪的。暂时也不知道怎么让.next只获取一次，获取失败就跳到下一个index，所以这个方案只能作罢。

with multiprocessing.Pool() as pool:
    it = pool.imap_unordered(self.check, links) #check为任务函数
    pbar = tqdm(total=len(links)) #提前设置任务总量
    while True:
        try:
            tmp = it.next(timeout=2)
            pbar.update()
        except multiprocessing.TimeoutError:
            print("link timeout: {}".format(tmp))
            continue
        except StopIteration:
            # signal that the iterator is exhausted
            # 如果所有的进程数据都获取完了，next会抛出该异常停止获取
            pbar.close()
            break

• 方法二改进版
  方案二中，.next一直会卡在超时的index上不继续迭代，所以不会有StopIteration异常使while循环停止，陷入死循环。所以想到一个比较简单粗暴的办法，将.next获取返回值的次数（即循环次数）限制为数组长度，避免陷入死循环。
  按照该办法可以正常进行超时处理了，但是测试发现这个办法存在一个bug：如果循环中有一个进程没有响应，则该进程后的所有进程返回值都无法获取到，全部被该进程的超时取代。因为.next函数会坚持不懈地去请求获取这个超时进程的数据，导致其他进程的数据没办法获取。emmm…这个办法也只能作罢。

• 方法三
  这个是看stackoverflow的大佬们提出的一个方案。建立一个守护进程池。由守护进程新建一个执行任务的进程，并监控执行进程的返回值，如果返回超时，则杀掉执行进程。这个是一圈下来的最佳方案，但是该方案与tqdm冲突，如果使用了tqdm，那么进程函数就不会执行（还没找到原因，哪位大佬知道的可以指点一下），所以需要自己另外写进度显示

# 执行函数
def check(self, url):
    headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:73.0) Gecko/20100101 Firefox/73.0",
               "Connection": "close"}
    try:
        res = requests.head(url, headers=headers)
        return url, res.status_code
    except Exception as e:
        print(e)

# 守护进程
def abortable_check(self, func, *args, **kwargs):
    timeout = kwargs.get('timeout', None)
    p = ThreadPool(1)
    res = p.apply_async(func, args=args)
    try:
        out = res.get(timeout)  # Wait timeout seconds for func to complete.
        # print(out)
        return out
    except multiprocessing.TimeoutError:
        print("{} timeout".format(args[0]))
        return (args[0], 444)

# 回调函数
def collectMyResult(self, result):
    if result is not None and result[1] == 404:
        self.brokenlinks.append(result[0])
    if result is not None and result[1] == 444:
        self.timeout.append(result[0])
    self.count += 1 #全局变量统计任务执行进度
    print('\r进度：{}/{}'.format(self.count,self.linkslen), end ='')


def main():
    pool = multiprocessing.Pool(maxtasksperchild=10)
    for l in links:
        a = [l]
        abortable_func = partial(self.abortable_check, self.check, timeout=5)
        pool.apply_async(abortable_func, args=a, callback=self.collectMyResult)