高级编程——网络通信：协程

目录

greenlet

gevent

gevent的应用

---

协程：任务之间通过生成器进行相互协同，数据传输

除了用生成器进行相互协调，还可以用第三方库，greenlet 和gevent 把任务封装成协程。

---

greenlet

是一个进行协程处理的第三方库 

下载：pip install greenlet

优点和功能：帮助我们快速的是实现协程

'''
greenlet:其实是一个封装好的协程
一个进行协程处理第三方库，所以需要下载安装：
pip install greenlet

功能：帮助我们简单快速的实现协程，一两个任务实现切换，多个的话就就比较麻烦
'''
import time
from greenlet import greenlet

#消费者
def consumer():
    while 1:   #不停接收数据   》》1
        res = pro.switch()    #获取数据，向（生产者协程）接收数据  》》5
        print(f'消费了数据{res}')


#生产者
def producer():
    for i in range(1,21):  #生产数据   》》2
        print(f"生产了数据{i}")
        # 发送数据到消费者              #》4
        conn.switch(i)  # 切换到消费者并传递数据
        time.sleep(1)
        print(f"第{i}次生产消费完成")

conn = greenlet(consumer)  #》》协程由greenlet库 实现  》3
pro = greenlet(producer)     #》》此时讲两个函数变成了协程
conn.switch() #启动消费者，消费者进入等待状态     》》6

---

gevent

是由 greenlet 的基础之上 研究出来的，一个进行 协程 处理的第三方库

from gevent import monkey

monkey.patch_all() #猴子补丁，临时修改对象的成员，进行修复
import gevent
import time
import queue

#消费者
def consumer(q):
    while 1:   #不停接收数据   》》1
        res = q.get()    #获取数据，向（生产者协程）接收数据  》》5
        print(f'消费了数据{res}')


#生产者
def producer(q):
    for i in range(1,21):  #生产数据   》》2
        print(f"生产了数据{i}")
        # 发送数据到消费者              #》4
        q.put(i)  # 将i传到队列里面来
        time.sleep(1)
        print(f"第{i}次生产消费完成")

if __name__ == '__main__':
    q = queue.Queue(3)  #geven 没有swith方法
    # # gevent 自动切换 自动挡 不需要手动切换，不需要使用switch
    conn = gevent.spawn(consumer,q)  #.spawn 是gevent里面的切换
    pro = gevent.spawn(producer,q)
    gevent.joinall([conn,pro])

---

 greenlet 和 gevent对比：

1.greenlet是手动挡，gevent是自动挡，自动的切换两边的任务，完成数据的传输。

1.greenlet中的切换是用 swith  而gevent 使用spawn切换的

---

网络编程小结

IO：就是读和写的操作，使用的这一切就是让CPU忙起来

---

gevent的应用

包括：同步执行和异步执行

同步方法

同步：从上往下 一次执行，每次执行只一个，执行10次任务函数

from gevent import monkey

monkey.patch_all()  # 猴子补丁，临时修改对象的成员，进行修复
import gevent
import time


def task(i):
    time.sleep(1)
    print(f'task执行完毕{i}次')


def synchronous():  # 同步执行方法
    '''同步：从上往下 一次执行，每次执行只一个，执行10次任务函数'''
    for i in range(10):
        task(i)



print("同步方法开始执行")
start = time.time()
synchronous()
print(f"同步方法执行完毕，共花费{time.time()-start}")


print("同步方法开始执行")
start = time.time()
synchronous()
print(f"同步方法执行完毕，共花费{time.time() - start}")

---

异步方法：

from gevent import monkey

monkey.patch_all()  # 猴子补丁，临时修改对象的成员，进行修复
import gevent
import time


def task(i):
    time.sleep(1)
    print(f'task执行完毕{i}次')


def synchronous():  # 同步执行方法
    '''同步：从上往下 一次执行，每次执行只一个，执行10次任务函数'''
    for i in range(10):
        task(i)


def asynchronous():  # 异步方法
    # gl =[]
    # for i in range (10):
    #     gl.append(gevent.spawn(task(i)))  #向列表里面执行方法
    gl = [gevent.spawn(task, i) for i in range(10)]  # 列表推导式生成10个协程任务
    gevent.joinall(gl)  # 等待所有任务执行完毕





print("异步方法开始执行")
start = time.time()
asynchronous()
print(f"异步方法执行完毕，共花费{time.time() - start}")

由此得出：异步方法比同步方法快。

浪费时间叫虚度，剥用时间叫生活