多任务-协程

一、yield

• 协程是python个中另外一种实现多任务的方式，只不过比线程更小占用更小执行单元

1.实现

import time


def task_1():
    while True:
        print("---1----")
        time.sleep(0.1)
        yield


def task_2():
    while True:
        print("---2----")
        time.sleep(0.1)
        yield


def main():
    t1 = task_1()
    t2 = task_2()
    # 先执行t1，当t1中遇到yield的时候，退出函数
    # 然后执行t2，当它遇到yield的时候，再次切换到t1中
    # 这样t1/t2/t1/t2的交替运行，最终实现了多任务....协程
    while True:
        next(t1)
        next(t2)
    

if __name__ == "__main__":
    main()

二、greenlet

1. 简介

• 为了更好使用协程来完成多任务，python中的greenlet模块对其封装，从而使得切换任务变的更加简单。
• 需要人工切换
• 依赖：pip install greenlet

2.用法

from greenlet import greenlet

• 实例化greenlet对象
  • g = greenlet(func):
• 调度:
  • g.switch()

3.实现

from greenlet import greenlet
import time


def test1():
    while True:
        print("---A--")
        gr2.switch()  # 切换任务
        print('延时0.5秒')
        time.sleep(0.5)


def test2():
    while True:
        print("---B--")
        gr1.switch()  # 切换任务
        print('延时0.5秒')
        time.sleep(0.5)


gr1 = greenlet(test1)
gr2 = greenlet(test2)

# 切换到gr1中运行
gr1.switch()

三、gevent

1.简介

• 对greentlet的进一步封装
• 原理是当一个greenlet遇到IO(指的是input output 输入输出，比如网络、文件操作等)操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行。
• 由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待IO
• 依赖：pip install gevent

2.用法

import gevent

实例化对象：

• g = gevent.spawn(run=None, *args, **kwargs)
  • run:接收的是一个函数
  • *args, **kwargs：传递到函数中的参数
• g.join():等待协程执行结束

同时实例化多个对象：

• gevent.joinall(objects=None)
  • objects:包含实例化对象的列表

3.实现

import gevent
import time


# monkey.patch_all()  # 将程序中用到的耗时操作的代码，换为gevent中自己实现的模块

def f1(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        # time.sleep(0.5)
        gevent.sleep(0.5)  # 导入gevent自己模块的sleep


def f2(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        # time.sleep(0.5)
        gevent.sleep(0.5)  # 导入gevent自己模块的sleep


def f3(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        # time.sleep(0.5)
        gevent.sleep(0.5)  # 导入gevent自己模块的sleep


print("----1---")
g1 = gevent.spawn(f1, 5)
print("----2---")
g2 = gevent.spawn(f2, 5)
print("----3---")
g3 = gevent.spawn(f3, 5)
print("----4---")
g1.join()
print('g1 is ok')
g2.join()
print('g2 is ok')
g3.join()
print('g3 is ok')

# gevent.joinall([
#        gevent.spawn(f1, 5),
#        gevent.spawn(f2, 5),
#        gevent.spawn(f3, 5),
# ])

4.gevent的monkey模块

• 解决延时操作只能使用gevent中的延时操作问题
• 本质上将程序中用到的耗时操作的代码，换为gevent中自己实现的模块
• monkey.patch_all()
  • 今后导入延时模块可以使用time，当碰到延时操作时，会自动将程序中用到的耗时操作的代码，换为gevent中自己实现的模块。

注：使用monkey模块需要将下面三句放在文件最上方。处于该代码下方的代码，遇到耗时任务才能进行自动调度切换

import gevent
from gevent import monkey
monkey.patch_all()

四、使用asyncio实现协程

1.格式

import asyncio

1.async def func（）：
         …
         # 当有耗时操作的时候切换协程
         await asyncio.sleep(x)
         …

2.a = func（）：调用之后返回的就是一个协程对象

3.创建协程的时间循环对象：
loop = asyncio.get_event_loop()

4.创建task对象的两种方式：
task = loop.create_task(a)
task = asyncio.ensure_future(a)

5.执行task对象
loop.run_until_complete(asyncio.wait(fs))
fs:可迭代对象，封装了多个任务对象，一般为列表

2.实现

import asyncio
import time


async def request(url):
    print('正在下载', url)
    # 在异步协程中如果出现了同步模块相关的代码，那么就无法实现异步。
    # time.sleep(2)
    # 当在asyncio中遇到阻塞操作必须进行手动挂起
    await asyncio.sleep(2)
    print('下载完毕', url)


start = time.time()
urls = [
    'www.baidu.com',
    'www.sogou.com',
    'www.goubanjia.com'
]

# 任务列表：存放多个任务对象
loop = asyncio.get_event_loop()
stasks = []
for url in urls:
    # 创建协程对象
    c = request(url)
    # 创建task对象
    task = asyncio.ensure_future(c)
    # task = loop.create_task(c)
    # 追加到列表中
    stasks.append(task)

# 需要将任务列表封装到wait中
loop.run_until_complete(asyncio.wait(stasks))

print(time.time() - start)

运行结果：

正在下载 www.baidu.com
正在下载 www.sogou.com
正在下载 www.goubanjia.com
下载完毕 www.baidu.com
下载完毕 www.sogou.com
下载完毕 www.goubanjia.com
2.0125160217285156

3.aiohttp实现多任务异步协程

• 上述中必须使用await asyncio.sleep(2)是因为它是基于异步的延时操作，使用time.sleep()是同步的延时操作，无法实现多任务并发执行
• 同理，requests.get是基于同步，必须使用基于异步的网络请求模块进行指定url的请求发送
• aiohttp:基于异步网络请求的模块
• 依赖：pip install aiohttp

例：

# 使用该模块中的ClientSession
import requests
import asyncio
import time
import aiohttp  # 安装包

start = time.time()

urls = ['http://www.sougou.com', 'http://www.goubanjia.com', 'http://www.baidu.com']
# for i in range(10):
#     urls.append('http://www.baidu.com')
print(urls)


async def get_page(url):
    async with aiohttp.ClientSession() as session:
        # get()、post():
        # 还可以携带的参数：headers,params/data,proxy='http://ip:port'
        async with await session.get(url) as response:
            # text()返回字符串形式的响应数据
            # read()返回的二进制形式的响应数据
            # json()返回的就是json对象
            print('开始获取', url)
            # 注意：获取响应数据操作之前一定要使用await进行手动挂起
            page_text = await response.text()
            # print('结束获取', page_text)
            print('结束获取', url)


tasks = []

loop = asyncio.get_event_loop()
for url in urls:
    c = get_page(url)
    task = asyncio.ensure_future(c)
    tasks.append(task)

loop.run_until_complete(asyncio.wait(tasks))

end = time.time()

print('总耗时:', end - start)

执行结果：

[‘http://www.sougou.com’, ‘http://www.goubanjia.com’, ‘http://www.baidu.com’]
开始获取 http://www.baidu.com
开始获取 http://www.goubanjia.com
结束获取 http://www.goubanjia.com
结束获取 http://www.baidu.com
开始获取 http://www.sougou.com
结束获取 http://www.sougou.com
总耗时: 0.3390941619873047