本文代码整理自：深入理解Python异步编程（上）

参考：A Web Crawler With asyncio Coroutines

一、同步阻塞方式

import socket

def blocking_way():

    sock = socket.socket()

    # blocking

    sock.connect(('example.com', 80))

    request = 'GET / HTTP/1.0\r\nHost: example.com\r\n\r\n'

    sock.send(request.encode('ascii'))

    response = b''

    chunk = sock.recv(4096)

    while chunk:

        response += chunk

        # blocking

        chunk = sock.recv(4096)

    return response

def sync_way():

    res = []

    for i in range(10):

        res.append(blocking_way())

    return len(res)

def main():

    start = time.time()

    print(sync_way())

    print(time.time() - start)

if __name__ == '__main__':

    import time

    main()

# 5.15s

二、同步多线程方式

import socket

from concurrent import futures

def blocking_way():

    sock = socket.socket()

    # blocking

    sock.connect(('example.com', 80))

    request = 'GET / HTTP/1.0\r\nHost: example.com\r\n\r\n'

    sock.send(request.encode('ascii'))

    response = b''

    chunk = sock.recv(4096)

    while chunk:

        response += chunk

        # blocking

        chunk = sock.recv(4096)

    return response

def thread_way():

    workers = 10

    with futures.ThreadPoolExecutor(workers) as executor:

        futs = {executor.submit(blocking_way) for i in range(10)}

    return len([fut.result() for fut in futs])

def main():

    start = time.time()

    print(thread_way())

    print(time.time() - start)

if __name__ == '__main__':

    import time

    main()

# 0.52s

　　

小提示

Python中的多线程因为GIL的存在，它们并不能利用CPU多核优势，

一个Python进程中，只允许有一个线程处于运行状态。

那为什么结果还是如预期，耗时缩减到了十分之一？

因为在做阻塞的系统调用时，例如sock.connect(),sock.recv()时，当前线程会释放GIL，

让别的线程有执行机会。但是单个线程内，在阻塞调用上还是阻塞的

Python中 time.sleep 是阻塞的，都知道使用它要谨慎，

但在多线程编程中，time.sleep 并不会阻塞其他线程。

　　

三、非阻塞+回调（即异步非阻塞）方式

事件循环+回调     实现单线程内异步编程

事件监听

OS将I/O状态的变化都封装成了事件，如可读事件、可写事件。

并且提供了专门的系统模块让应用程序可以接收事件通知。这个模块就是select。

让应用程序可以通过select注册文件描述符和回调函数。

当文件描述符的状态发生变化时，select 就调用事先注册的回调函数。

select因其算法效率比较低，后来改进成了poll；

再后来又有进一步改进，BSD内核改进成了kqueue模块，而Linux内核改进成了epoll模块。这四个模块的作用都相同，暴露给程序员使用的API也几乎一致，

区别在于kqueue 和 epoll 在处理大量文件描述符时效率更高。

selectors模块

Python标准库提供的selectors模块是对底层select/poll/epoll/kqueue的封装。

DefaultSelector类会根据 OS 环境自动选择最佳的模块，

那在 Linux 2.5.44 及更新的版本上都是epoll了。

　　

#!/usr/bin/python3.5

# encoding: utf-8

import socket

from selectors import DefaultSelector, EVENT_WRITE, EVENT_READ

selector = DefaultSelector()

stopped = False

urls_todo = {'/', '/1', '/2', '/3', '/4', '/5', '/6', '/7', '/8', '/9'}

class Crawler:

    def __init__(self, url):

        self.url = url

        self.sock = None

        self.response = b''

    def fetch(self):

        self.sock = socket.socket()

        self.sock.setblocking(False)

        try:

            self.sock.connect(('example.com', 80))

        except BlockingIOError:

            pass

        selector.register(self.sock.fileno(), EVENT_WRITE, self.connected)

    def connected(self, key, mask):

        selector.unregister(key.fd)

        get = 'GET {0} HTTP/1.0\r\nHost: example.com\r\n\r\n'.format(self.url)

        self.sock.send(get.encode('ascii'))

        selector.register(key.fd, EVENT_READ, self.read_response)

    def read_response(self, key, mask):

        global stopped

        # 如果响应大于4KB，下一次循环会继续读

        chunk = self.sock.recv(4096)

        if chunk:

            self.response += chunk

        else:

            selector.unregister(key.fd)

            urls_todo.remove(self.url)

            if not urls_todo:

                stopped = True

# 事件循环

def loop():

    while not stopped:

        # 阻塞, 直到一个事件发生

        events = selector.select()

        for event_key, event_mask in events:

            callback = event_key.data

            callback(event_key, event_mask)

if __name__ == '__main__':

    import time

    start = time.time()

    for url in urls_todo:

        crawler = Crawler(url)

        crawler.fetch()

    loop()

    print(time.time() - start)

# 0.53s

回调层次过多的缺点：

- 共享状态管理困难

在回调的版本中，我们必须在Crawler实例化后的对象self里保存它自己的sock对象。

如果不是采用OOP的编程风格，那需要把要共享的状态接力似的传递给每一个回调。

多个异步调用之间，到底要共享哪些状态，事先就得考虑清楚，精心设计。

- 错误处理困难

一连串的回调构成一个完整的调用链；

如果其中一环抛了异常怎么办？

整个调用链断掉，接力传递的状态也会丢失，这种现象称为调用栈撕裂。

所以，为了防止栈撕裂，异常必须以数据的形式返回，而不是直接抛出异常，

然后每个回调中需要检查上次调用的返回值，以防错误吞没。

四、Python 对异步I/O的优化之路

#!/usr/bin/python3.5

# encoding: utf-8

import socket

from selectors import DefaultSelector, EVENT_WRITE, EVENT_READ

selector = DefaultSelector()

stopped = False

urls_todo = {'/', '/1', '/2', '/3', '/4', '/5', '/6', '/7', '/8', '/9'}

class Future:

    def __init__(self):

        self.result = None

        self._callbacks = []

    def add_done_callback(self, fn):

        self._callbacks.append(fn)

    def set_result(self, result):

        self.result = result

        for fn in self._callbacks:

            fn(self)

class Crawler:

    def __init__(self, url):

        self.url = url

        self.response = b''

    def fetch(self):

        sock = socket.socket()

        sock.setblocking(False)

        try:

            sock.connect(('example.com', 80))

        except BlockingIOError:

            pass

        f = Future()

        def on_connected():

            f.set_result(None)

        selector.register(sock.fileno(), EVENT_WRITE, on_connected)

        yield f

        selector.unregister(sock.fileno())

        get = 'GET {0} HTTP/1.0\r\nHost: example.com\r\n\r\n'.format(self.url)

        sock.send(get.encode('ascii'))

        global stopped

        while True:

            f = Future()

            def on_readable():

                f.set_result(sock.recv(4096))

            selector.register(sock.fileno(), EVENT_READ, on_readable)

            chunk = yield f

            selector.unregister(sock.fileno())

            if chunk:

                self.response += chunk

            else:

                urls_todo.remove(self.url)

                if not urls_todo:

                    stopped = True

                break

class Task:

    def __init__(self, coro):

        self.coro = coro

        f = Future()

        f.set_result(None)

        self.step(f)

    def step(self, future):

        try:

            # send会进入到coro执行, 即fetch, 直到下次yield

            # next_future 为yield返回的对象

            next_future = self.coro.send(future.result)

        except StopIteration:

            return

        next_future.add_done_callback(self.step)

# 事件循环

def loop():

    while not stopped:

        # 阻塞, 直到一个事件发生

        events = selector.select()

        for event_key, event_mask in events:

            callback = event_key.data

            callback()

if __name__ == '__main__':

    import time

    start = time.time()

    for url in urls_todo:

        crawler = Crawler(url)

        Task(crawler.fetch())

    loop()

    print(time.time() - start)

# 0.53s

在前辈的基础上做了一点更改：

#!/usr/bin/python3

# encoding: utf-8

import socket

from selectors import DefaultSelector, EVENT_WRITE, EVENT_READ

selector = DefaultSelector()

stopped = False

urls_todo = {'/', '/1', '/2', '/3', '/4', '/5', '/6', '/7', '/8', '/9'}

class Future:

    def __init__(self):

        self.result = None

        self._callback = None   # 原来是用列表来保存

    def add_done_callback(self, fn):

        self._callback = fn

    def set_result(self, result):

        self.result = result

        # 因为只有一个对应的 Task.step()函数

        if self._callback:

            self._callback(self)

class Crawler:

    def __init__(self, url):

        self.url = url

        self.response = b''

    def fetch(self):

        sock = socket.socket()

        sock.setblocking(False)

        try:

            sock.connect(('example.com', 80))

        except BlockingIOError:

            pass

        f = Future()

        def on_connected():

            f.set_result(None)

        selector.register(sock.fileno(), EVENT_WRITE, on_connected)

        yield f

        selector.unregister(sock.fileno())

        get = 'GET {0} HTTP/1.0\r\nHost: example.com\r\n\r\n'.format(self.url)

        sock.send(get.encode('ascii'))

        global stopped

        while True:

            f = Future()

            def on_readable():

                f.set_result(sock.recv(4096))

            selector.register(sock.fileno(), EVENT_READ, on_readable)

            chunk = yield f

            selector.unregister(sock.fileno())

            if chunk:

                self.response += chunk

            else:

                urls_todo.remove(self.url)

                if not urls_todo:

                    stopped = True

                break

class Task:

    def __init__(self, coro):

        self.coro = coro

        f = Future()

        f.set_result(None)

        self.step(f)

    def step(self, future):

        try:

            # send会进入到coro执行, 即fetch, 直到下次yield

            # next_future 为yield返回的对象

            next_future = self.coro.send(future.result)

        except StopIteration:

            return

        next_future.add_done_callback(self.step)

        print(next_future._callback)

# 事件循环

def loop():

    while not stopped:

        # 阻塞, 直到一个事件发生

        events = selector.select()

        for event_key, event_mask in events:

            callback = event_key.data

            callback()

if __name__ == '__main__':

    import time

    start = time.time()

    c_list = []

    for url in urls_todo:

        crawler = Crawler(url)

        Task(crawler.fetch())

        c_list.append(crawler)

    loop()

    # 增加了对爬取内容的输出

    for crawler in c_list:

        print(crawler.response)

    print(time.time() - start)

　　

五、用 yield from 改进生成器协程

yield可以直接作用于普通Python对象，而yield from却不行，

所以我们对Future还要进一步改造，把它变成一个iterable对象就可以了

#!/usr/bin/python3.5

# -*- coding:utf-8 -*-

import socket

from selectors import DefaultSelector, EVENT_WRITE, EVENT_READ

selector = DefaultSelector()

stopped = False

urls_todo = {'/', '/1', '/2', '/3', '/4', '/5', '/6', '/7', '/8', '/9'}

def connect(sock, address):

    f = Future()

    sock.setblocking(False)

    try:

        sock.connect(address)

    except BlockingIOError:

        pass

    def on_connected():

        f.set_result(None)

    selector.register(sock.fileno(), EVENT_WRITE, on_connected)

    yield from f

    selector.unregister(sock.fileno())

def read(sock):

    f = Future()

    def on_readable():

        f.set_result(sock.recv(4096))

    selector.register(sock.fileno(), EVENT_READ, on_readable)

    chunk = yield from f

    selector.unregister(sock.fileno())

    return chunk

def read_all(sock):

    response = []

    chunk = yield from read(sock)

    while chunk:

        response.append(chunk)

        chunk = yield from read(sock)

    return b''.join(response)

class Future:

    def __init__(self):

        self.result = None

        self._callbacks = []

    def add_done_callback(self, fn):

        self._callbacks.append(fn)

    def set_result(self, result):

        self.result = result

        for fn in self._callbacks:

            fn(self)

    def __iter__(self):

        yield self

        return self.result

class Crawler:

    def __init__(self, url):

        self.url = url

        self.response = b''

    def fetch(self):

        global stopped

        sock = socket.socket()

        yield from connect(sock, ('example.com', 80))

        get = 'GET {0} HTTP/1.0\r\nHost: example.com\r\n\r\n'.format(self.url)

        sock.send(get.encode('ascii'))

        self.response = yield from read_all(sock)

        urls_todo.remove(self.url)

        if not urls_todo:

            stopped = True

class Task:

    def __init__(self, coro):

        self.coro = coro

        f = Future()

        f.set_result(None)

        self.step(f)

    def step(self, future):

        try:

            # send会进入到coro执行, 即fetch, 直到下次yield

            # next_future 为yield返回的对象

            next_future = self.coro.send(future.result)

        except StopIteration:

            return

        next_future.add_done_callback(self.step)

# 事件循环

def loop():

    while not stopped:

        # 阻塞, 直到一个事件发生

        events = selector.select()

        for event_key, event_mask in events:

            callback = event_key.data

            callback()

if __name__ == '__main__':

    import time

    start = time.time()

    for url in urls_todo:

        crawler = Crawler(url)

        Task(crawler.fetch())

    loop()

    print(time.time() - start)

# 0.53s

　　

六、asyncio和原生协程初体验

asyncio是Python 3.4 试验性引入的异步I/O框架（PEP 3156），提供了基于协程做异步I/O编写单线程并发代码的基础设施。

其核心组件有事件循环（Event Loop）、协程(Coroutine）、任务(Task)、未来对象(Future)以及其他一些扩充和辅助性质的模块。

在引入asyncio的时候，还提供了一个装饰器@asyncio.coroutine用于装饰使用了yield from的函数，以标记其为协程。但并不强制使用这个装饰器。

在 3.5 中新增了async/await语法（PEP 492），对协程有了明确而显式的支持，称之为原生协程。

async/await 和 yield from这两种风格的协程底层复用共同的实现，而且相互兼容。

在Python 3.6 中asyncio库“转正”，不再是实验性质的，成为标准库的正式一员。

#!/usr/bin/python3.5

# -*- coding:utf-8 -*-

import asyncio

import aiohttp

host = 'http://example.com'

urls_todo = {'/', '/1', '/2', '/3', '/4', '/5', '/6', '/7', '/8', '/9'}

loop = asyncio.get_event_loop()

async def fetch(url):

    async with aiohttp.ClientSession(loop=loop) as session:

        async with session.get(url) as response:

            response = await response.read()

            return response

if __name__ == '__main__':

    import time

    start = time.time()

    tasks = [fetch(host + url) for url in urls_todo]

    loop.run_until_complete(asyncio.gather(*tasks))

    print(time.time() - start)

# 0.54s

2019-06-26补充demo示例

 import time

 import asyncio

 import requests

 urls = [

     'http://httpbin.org/get',

     'http://httpbin.org/ip',

     'http://httpbin.org/json',

     'http://httpbin.org/uuid',

     'http://httpbin.org/user-agent',

     'http://httpbin.org/headers',

     'http://httpbin.org/response-headers',

 ]

 def get_result(url):

     d = requests.get(url)

     dd = d.json()

     return dd

 start = time.time()

 results = []

 for url in urls:

     d = get_result(url)

     results.append(d)

 print('RUN : {}'.format(time.time()-start))

 print(results)

耗时：RUN : 6.703306198120117

 import time

 import asyncio

 import requests

 urls = [

     'http://httpbin.org/get',

     'http://httpbin.org/ip',

     'http://httpbin.org/json',

     'http://httpbin.org/uuid',

     'http://httpbin.org/user-agent',

     'http://httpbin.org/headers',

     'http://httpbin.org/response-headers',

 ]

 def myfunc(url):

     d = requests.get(url)

     dd = d.json()

     return dd

 @asyncio.coroutine

 def fetch_async(func, url):

     loop = asyncio.get_event_loop()

     future = loop.run_in_executor(None, func, url)

     data = yield from future

     return data

 start = time.time()

 loop = asyncio.get_event_loop()

 tasks = [fetch_async(myfunc, url) for url in urls]

 results = loop.run_until_complete(asyncio.gather(*tasks))

 loop.close()

 print('RUN : {}'.format(time.time()-start))

 print(results)

耗时：RUN : 1.0276665687561035

补充说明：

run_in_executor(self, executor, func, *args) 第一个参数是传入一个executor（即concurrent.futures.ThreadPoolExecutor，线程池对象）,
不传的话，默认使用 (os.cpu_count() or 1) * 5 这个数值，即如果是4核的cpu，就会对应生成一个含有20线程的线程池，来执行传入的第二个函数func.
所以run_in_executor其实开启了新的线程，再协调各个线程。

　　

深入理解Python异步编程（上）的更多相关文章

  1. 深入理解 Python 异步编程(上)

    http://python.jobbole.com/88291/ 前言 很多朋友对异步编程都处于"听说很强大"的认知状态.鲜有在生产项目中使用它.而使用它的同学,则大多数都停留在知 ...

  2. 这篇文章讲得精彩-深入理解 Python 异步编程(上)！

    可惜,二和三现在还没有出来~ ~~~~~~~~~~~~~~~~~~~~~~~~~ http://python.jobbole.com/88291/ ~~~~~~~~~~~~~~~~~~~~~~~~~~ ...

  3. 快速理解Python异步编程的基本原理

    第一个例子 假设你需要用电饭煲煮饭,用洗衣机洗衣服,给朋友打电话让他过来吃饭.其中,电饭煲需要30分钟才能把饭煮好,洗衣机需要40分钟才能把衣服洗好,朋友需要50分钟才能到你家.那么,是不是你需要在这 ...

  4. python 异步编程

    Python 3.5 协程究竟是个啥 Yushneng · Mar 10th, 2016 原文链接 : How the heck does async/await work in Python 3.5 ...

  5. Python 异步编程笔记：asyncio

    个人笔记,不保证正确. 虽然说看到很多人不看好 asyncio,但是这个东西还是必须学的.. 基于协程的异步,在很多语言中都有,学会了 Python 的,就一通百通. 一.生成器 generator ...

  6. 最新Python异步编程详解

    我们都知道对于I/O相关的程序来说,异步编程可以大幅度的提高系统的吞吐量,因为在某个I/O操作的读写过程中,系统可以先去处理其它的操作(通常是其它的I/O操作),那么Python中是如何实现异步编程的 ...

  7. (转)python异步编程--回调模型(selectors模块)

    原文:https://www.cnblogs.com/zzzlw/p/9384308.html#top 目录 0. 参考地址 1. 前言 2. 核心类 3. SelectSelector核心函数代码分 ...

  8. python异步编程--回调模型(selectors模块)

    目录 0. 参考地址 1. 前言 2. 核心类 3. SelectSelector核心函数代码分析 3.1 注册 3.2 注销 3.3 查询 4. 别名 5. 总结 6. 代码报错问题 1. 文件描述 ...

  9. python异步编程 （转载）

    Python Async/Await入门指南   转自:https://zhuanlan.zhihu.com/p/27258289 本文将会讲述Python 3.5之后出现的async/await的使 ...

随机推荐

  1. 【NOIP2018 Day1】题解

    T3 rp++; 今天题比较简单 而且考了很多嫌疑原题? 大家基本250+ 本蒟蒻...T3十分看脸 再次祝rp++; T1 积木大赛本赛嘛 如果d[i] < d[i - 1] ans += d ...

  2. Shell 字符截取命令 Cut

    1.Cut 命令 # cut [选项] 文件名 选项 : -f 列号 提取第几列   -d 分隔符,按照指定分隔符分割列 2.例子 cut -f 1,4 -d ":" /etc/p ...

  3. centos7修改默认网卡名称

    问题场景: 使用centos7有好一阵子了,安装过centos7的朋友都会发现网卡命名跟6.x系统的不一样,类似ifcfg-eno16780032, ens192,或者enp2s0等其他不习惯的.不容 ...

  4. linux(fedora) 第一课

    1.Linux查看ip地址:ifconfig(interface config) 2.find / -name ifconfig (查找 从/开始找 找名字 匹配ifconfing) 复制命令:Ctr ...

  5. 2019 校内赛 RPG的天赋分支(贪心)

    Problem Description 很多游戏都有天赋树的概念,天赋树的不同分支具有不同的属性加成,那么合理选择分支就非常重要了.Luke最近沉迷一款RPG游戏,它的天赋树机制如下:角色具有n个可选 ...

  6. nc 使用实例

    nc.exe -h即可看到各参数的使用方法.基本格式:nc [-options] hostname port[s] [ports] ...nc -l -p port [options] [hostna ...

  7. poj1193 内存分配

    气死我了...这个毒瘤内存分配..... 优先队列 + 链表模拟,看起来搞一搞就好了却WA来WA去... 最后对拍手动找才发现错误: erase的时候不要急急忙忙插入wait!要把同一时期的erase ...

  8. LOJ#2542 随机游走

    解:首先minmax容斥变成经过集合t的第一个点就停止的期望步数.对于某个t,设从x开始的期望步数为f(x) 如果x∈t,f(x) = 0.否则f(x) = ∑f(y) / in[x] + 1 树上高 ...

  9. win10 python3.5 自动补全设置

    https://www.cnblogs.com/lgh344902118/p/8521437.html # python startup file import readline import rlc ...

  10. linux系统调用之用户管理

    getuid 获取用户标识号 setuid 设置用户标志号 getgid 获取组标识号 setgid 设置组标志号 getegid 获取有效组标识号 setegid 设置有效组标识号 geteuid ...