python 3.x asyncio与ThreadPoolExecutor结合使用,完成阻塞IO的请求

asyncio与ThreadPoolExecutor结合使用,完成阻塞IO的请求

• 协程模式是单线程的,为什么又多出一个多线程呢???
  • asyncio是异步IO编程的解决方案,异步IO是包含多线程,多进程以及协程.　　
  • 所以asyncio即可完成多线程(多进程)也可以完成协程.　　
  • 所以在协程里面也可以使用多线程.　　
• 什么时候在协程中使用多线程呢???
  • 协程里面是不能加入阻塞IO的,但是某些时候(比如说某一个库或者说某一个接口,只能提供阻塞怎么办?实际很简单把它放在一个线程中去做即可)　　
  • 在协程中集成阻塞IO,比如说MySQL库是阻塞的,PyMySQL和MySQLClient都是阻塞的,那在协程中如果去强行使用MySQL这三个库怎么办?就可以使用多线程　　

• 在asyncio中集成线程池
  • run_in_executor(self, executor, func, *args):将某个阻塞IO的函数放到executor(ThreadPoolExecutor)中运行.　　
    • executor: 线程池执行者　　　　
    • func: 函数名　　　　
    • *args: 函数的参数　　　　

run_in_executor(self, executor, func, *args)源码

       def run_in_executor(self, executor, func, *args):
            self._check_closed()
            if self._debug:
                self._check_callback(func, 'run_in_executor')
            if executor is None:
                executor = self._default_executor

                # 1.如果executor为None的话,就会声明一个ThreadPoolExecutor()
                if executor is None:
                    executor = concurrent.futures.ThreadPoolExecutor()

                    # 2.将executor赋值给_default_executor,所以说将executor放到self里面(实例变量)也就是loop里面,作为一个变量
                    self._default_executor = executor

            # wrap_future()方法将executor.submit()执行后返回的future对象,封装成新的futures(也就是协程的futures)
            return futures.wrap_future(executor.submit(func, *args), loop=self)

 

submit(self, fn, *args, **kwargs)源码

def submit(self, fn, *args, **kwargs):
            with self._shutdown_lock:
                if self._shutdown:
                    raise RuntimeError('cannot schedule new futures after shutdown')

                f = _base.Future()
                w = _WorkItem(f, fn, args, kwargs)

                self._work_queue.put(w)
                self._adjust_thread_count()

                # 返回future对象.
                return f

 

 

import asyncio
from concurrent.futures import ThreadPoolExecutor
import socket
# urlparse的作用是对url进行解析.
from urllib.parse import urlparse
import time


# get_url是一个阻塞的接口.将阻塞接口与asyncio结合起来.
def get_url(url):
    new_url = urlparse(url)
    host = new_url.netloc
    path = new_url.path
    if path == "":
        path = "/"

    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client.connect((host, 80))  # 阻塞不会消耗cpu
    client.send("GET {} HTTP/1.1\r\nHost:{}\r\nConnection:close\r\n\r\n".format(path, host).encode("utf8"))

    data = b""
    while True:
        re_data = client.recv(1024)
        if re_data:
            data += re_data
        else:
            break

    data = data.decode("utf8")
    html_data = data.split("\r\n\r\n")[1]
    print(html_data)
    client.close()


if __name__ == "__main__":
    start_time = time.time()
    loop = asyncio.get_event_loop()
    executor = ThreadPoolExecutor(3)
    # 要在asyncio中等待task的执行完成就要使用run_until_complete()方法,而这个方法接收一个list参数,所以需要声明一个list
    tasks = []
    # 为了测试asyncio与ThreadPoolExecutor结合的性能,一次性放20个函数进来.
    for i in range(1, 21):
        # 获取某一个商品的详情的url,随机获取前20个商品详情的url
        url = "http://shop.projectsedu.com/goods/{}/".format(i)
        # 这个提交过程是快速返回的.是asyncio的task
        # 通过run_in_executor()方法的源码得知,将线程的future执行了一个包装,包装成协程的future,
        # 这样的话,就可以进行await,所以返回一个task.
        # run_in_executor()方法运行原理还是在内部去声明一个线程池,然后这里面的阻塞代码放到线程池里面去运行.
        # 与线程池是一样的没有多高的性能.
        task = loop.run_in_executor(executor, get_url, url)
        tasks.append(task)
    # 很简单的将阻塞的url放到loop中,同时也不会影响协程的运行.
    loop.run_until_complete(asyncio.gather(*tasks))

    print("code run finished use time: {}".format(time.time() - start_time))

"""
输出结果:
    code run finished use time: 8.041460037231445
    
通过运行的时间得出结论,这种性能无非还是将一些代码放到线程池中运行.避免不了线程池的一些问题.
在使用协程模式的时候,在协程里面不要去调用阻塞方式.但是一定要在协程中调用阻塞方式,就可以把阻塞方式拿到线程池中运行.
这就是即将要说明的如何将线程池与asyncio相结合.来模拟http请求.
"""

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

********