python 多进程和异步io的有机结合 Error in atexit._run_exitfuncs
众所周知，python的多线程开发在GIL（全局器解释锁）下饱受诟病，在单核模式下搞多线程对效率的提升相当有限。于是大家的共识就是搞io密集的程序，建议采用多线程，计算密集型的程序就搞多进程。近期的一些开发经历，让我大量尝试采用多进程和异步io的方式来提高效率。
一.采用多进程。
1.用过multiprocessing.process和queue及pool，但是一直有报错，位置在multiprocessing.spawn的_main(fd,parent_sentinel)中reduction.pickle.load(from_parent)。网上提供了各种诸如修改权限，修改reduction协议类型的方案，始终未能解决。最后竟然是更新了python版本后不药而愈，但最后放弃了这种方式。
2.使用concurrent.futures.ProcessPoolExecutor，官方文档很详细。程序运行也很不错，但是在脚本执行完毕后退出时抛出异常。Error in atexit._run_exitfuncs。大致的内容是handle is closed，通过追踪大致可以判断出脚本执行完毕时，会有futures.process的_python_exit()执行，此时ProcessPoolExecutor执行完毕后释放，没有线程可以被wakeup，所以报错。引起这个问题的是官方推荐的with as写法，with as 执行完毕后会将对象释放，结果在退出的时候引发异常。
解决方案也很反常，不使用with as的自动释放，也不使用shutdown手动释放，而是不释放，在整个脚本执行完毕的时候，由_python_exit()进行释放。
有意思的是concurrent.futures.process文档里有这么一段注释，可以自行研究。
# Workers are created as daemon threads and processes. This is done to allow the
# interpreter to exit when there are still idle processes in a
# ProcessPoolExecutor's process pool (i.e. shutdown() was not called). However,
# allowing workers to die with the interpreter has two undesirable properties:
# - The workers would still be running during interpreter shutdown,
# meaning that they would fail in unpredictable ways.
# - The workers could be killed while evaluating a work item, which could
# be bad if the callable being evaluated has external side-effects e.g.
# writing to a file.
#
# To work around this problem, an exit handler is installed which tells the
# workers to exit when their work queues are empty and then waits until the
# threads/processes finish.
二.采用异步io。
python在3.4中有了asyncio。官方给的示例可以看出来这是个消息循环，eventloop是在当前的上下文中提供的，而且可以和协程一起执行。最新的文档里可以看到eventloop已经不再只是同协程一起提供异步了。
我们可以将多个耗时的任务进行封装，丢进eventloop中，当线程执行到需要等待的操作如io，主线程不会等待，而是切换执行到下一个可执行任务，因此可以实现并发执行。
三.多进程和异步io结合。
经过尝试多线程中没有找到使用异步io的方式，因为eventloop是从当前上下文中提供的，也就是主线程。于是换了个思路，使用多进程，让每个进程的‘主线程’通过异步io来实现并发，经多次尝试后这种方案是可行的。
因为同时运行的进程数量上限是受cpu内核数量的上限影响的，一般的建议是不超过内核数量，但是在一些场景的限制下为了提高效率，单纯受限的多进程不能满足要求的时候，不妨将多进程的‘主进程’结合并发来提高效率。
由于没有实际测试性能，不能断言究竟哪种方式效率更高，毕竟也与任务内容有关。这只是一种思路，留待日后验证。
代码如下：
import asyncio
import aiohttp
from concurrent.futures import ProcessPoolExecutor, as_completed ,ThreadPoolExecutor
import time
async def post_http():
# 示例
url = ''
data = ''
async with aiohttp.ClientSession() as session:
async with session.post(url=url, data=data, headers={}, timeout=60) as resp:
r_json = await resp.json()
return r_json
async def t_handler(data, t_flag, p_flag, semaphore):
async with semaphore:
for d in data:
print(f'pid:{p_flag} tid:{t_flag} data:{d}')
await asyncio.sleep(1) # 处理费时的io操作，比如httprequest
return
def p_handler(datas, p_flag):
# 线程并发数需要有限制 linux打开文件最大默认为1024 win为509 待确认
ts = time.time()
num = 10 # 最大并发数
count = len(datas)
block = int(count / num) + 1
tar_datas = [datas[i * block: (i + 1) * block if (i + 1) * block < count else count] for i in range(num)]
semaphore = asyncio.Semaphore(num)
tasks = [t_handler(d, i, p_flag, semaphore) for i, d in enumerate(tar_datas)]
loop = asyncio.get_event_loop() # 基于当前线程 ，故在多线程中无法使用 只能在多进程中使用
loop.run_until_complete(asyncio.wait(tasks))
loop.close()
return f'\033[0;32mprocess {p_flag} :cost {time.time() - ts}\033[0m'
if __name__ == '__main__':
ts = time.time()
datas = [i for i in range(1000)]
datas = [datas[i * 100:(i + 1) * 100] for i in range(10)] # 每个进程要处理的数据
# 启动异步io 主线程调用 event_loop 在当前线程下启动异步io 实现并发
# res = p_handler(datas,1)
# print(res)
p_num = 10
block_len = 100
datas = [datas[i * 100:(i + 1) * 100] for i in range(p_num)] # 每个进程要处理的数据
# ProcessPoolExecutor 可能与运行环境有关 官方的 with as 会主动释放线程 导致主线程退出时找不到进程池内进程已经被释放 导致Error in atexit._run_exitfuncs异常
executor = ProcessPoolExecutor(p_num)
futures = [executor.submit(p_handler, d, p_flag) for p_flag, d in enumerate(datas)]
for f in as_completed(futures):
if f.done():
res = f.result()
print(res)
print(f'Exit!! cost:{time.time() - ts}')
