[Python] 协程学习过程

开始

之前一直在做那个rProxy的项目，后来发现，服务端不用协程或者异步编程这样的手段是不行的，最主要的问题就是对于每个http请求都对应一个线程，这个开销非常大。对于一个网页而言，四五十个http请求已经是非常常见的事情了，如果有很多个客户端，一下子线程数可能得有几百个。而Python的多线程众所周知的虚假。

所以我就会考虑使用异步套接字来做。

在异步套接字中会需要一个主循环用来管理套接字，手动管理比较麻烦，后来了解到了协程。发现这个就是非常适合做这个事情的啊。

而Python的库就是asyncio 官方文档在这里

<协程与任务 — Python 3.9.1 文档>

不过后面又发现了一个更神奇的东西，就是gevent这个库，项目在这里

pip不能安装的话whl包在这里Python Extension Packages for Windows - Christoph Gohlke (uci.edu)

协程

线程的话，已经很熟悉了。对于需要大量IO操作的程序，基本上首选多线程。但是线程也有一些缺点，例如说需要考虑线程安全问题，线程间切换也会损耗性能。

非常常见的现象就是，使用Python多线程写爬虫我的电脑大约80线程就已经是极限了，再增加线程也不会有什么速度上的加快了。

此时，协程就出现了

一个线程可以包含很多的协程，而协程之间的切换不需要经过系统，不需要进行内核态的切换。还有各种复杂的保存现场。

学习过程

这里就记录一下对协程的学习过程，主要是两种。

一个是以asyncio为主的协程

另一个是以第三方库gevent为主的协程

## asyncio

asyncio是最先了解到的技术，可以用于实现协程。一个简单的Demo如下。

import asyncio as ayc

i = 0

async def p(c):
    global i
    while True:
        print(f"t{c}: {i}")
        i+=1
        await ayc.sleep(0)
    
async def fun():
    t1 = ayc.create_task(p(1))
    t2 = ayc.create_task(p(2))

    await t1
    await t2

def main():
    ayc.run(fun())

if __name__ == "__main__":
    main()

这个例子只是对一个公共变量进行叠加，结果

运行之后能够看到数字递增，而且非常有序，t1,t2两个协程分工交替出现

而多线程不加锁的情况下，很容易出现以下的情况。也就是出现t1 t2时间分配不均匀的情况，并且线程不安全 89914出现在了89916后面

多线程代码如下

import threading

i = 0

def fun(c):
    global i
    while True:
        print(f"t{c}: {i}")
        i+=1
    
def main():
    threading.Thread(target=fun,args=(1,)).start()
    threading.Thread(target=fun,args=(2,)).start()
    
if __name__ == "__main__":
    main()

目前到这里就没有问题，但是等我实际写代码的时候，发现一个问题。

也就是，如果一个IO操作阻塞，则整个线程卡死，导致协程不能正常切换。例如下面的代码

import requests
import asyncio
import time

urls = ["https://www.baidu.com","https://www.cnblogs.com/","https://blog.csdn.net/"]

async def getHtml(url):
    stime = time.time()
    r = requests.get(url)
    print(f"{url}, {r.status_code}, {time.time() - stime}")
    
async def main():
    tasks = []
    for url in urls:
        tasks.append(asyncio.create_task(getHtml(url)))
    
    stime = time.time()
    await asyncio.wait(tasks)
    print(f"Done, {time.time() - stime}")
    
if __name__ == "__main__":
    asyncio.run(main())

代码作用是分别请求三个域名，记录响应时间以及总时间

结果如下，注意，此时虽然用了协程，但是总时间却是三次请求时间之和。

原因就是，直接使用asyncio实现协程并不会监听IO阻塞情况，也就是在requests.get()的时候，协程没有切换。导致整个线程阻塞。

所以实际的执行流依旧是串行执行，那么协程就毫无意义。

aiohttp#

而这个问题存在的原因就在于，requests这个库是同步库，底层是同步socket。对应的，另一个名为 aiohttp的第三方库是基于asyncio开发的http库可以解决这个问题。

aiohttp官方文档如下

一个Demo如下

import aiohttp
import asyncio
import time

urls = ["https://www.baidu.com","https://www.cnblogs.com/","https://blog.csdn.net/"]

async def getHtml(url):
    print(f"请求: {url}")
    stime = time.time()
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            print(f"status: {response.status}, {time.time() - stime}")
            # html = await response.text()
            # print(f"Body: {html[:20]}")
          
async def main():
    tasks = []
    for url in urls:
        tasks.append(asyncio.create_task(getHtml(url)))
    await asyncio.wait(tasks)
    print("Done")

asyncio.run(main())

最后结果如下

可以看到总花费时间近似于最长请求时间。也就是完成了异步请求

那么，到这里似乎就已经圆满了。但是，我还了解到了gevent这个库

gevent#

直接贴代码

from gevent import monkey; monkey.patch_all()
import gevent
import requests
import asyncio
import time

urls = ["https://www.baidu.com","https://www.cnblogs.com/","https://blog.csdn.net/"]

def getHtml(url):
    stime = time.time()
    r = requests.get(url)
    print(f"{url}, {r.status_code}, {time.time() - stime}")
    
def main():
    tasks = []
    for url in urls:
        tasks.append(gevent.spawn(getHtml,url))
    
    stime = time.time()
    gevent.joinall(tasks)
    print(f"Done, {time.time() - stime}")
    
if __name__ == "__main__":
    main()