协程、greenlet 协程与gevent 协程

╰+哭是因爲堅強的太久メ 2022-05-16 03:34 459阅读 0赞

**1.协程**

### 为什么要使用协程 ###

*  协程最大的优势就是协程极高的执行效率。子程序切换由程序自身控制，因此，没有线程切换的开销
 *  第二大优势就是不需要多线程的锁机制，阻塞自动切换

**协程即是生成器对象的yield和send方法的配合使用**

### 生成器语法 ###

yield 一个对象

*  返回这个对象
 *  暂停这个函数
 *  能带下次next重新激活

def func():
        print('第一次执行')
        yield 1 #返回1，并暂停函数
        print('第二次执行')
        yield 2 #返回2，并暂停函数
        print('第三次执行')
        #没有代码了，引发异常
    f = func()
    v1 = next(f) #直至第一个yield
    print(v1) #输出第一个yield的值
    v2 = next(f) #直至第二个yield
    print(v2) #输出第三个yield的值
    v3 = next(f) #输出至下一个yield，但并没有下一个yield，抛出StopItertion异常

第一次执行
    1
    第二次执行
    2
    第三次执行
    Traceback (most recent call last):
      File "/home/pyvip/py_case/网络编程/生成器.py", line 13, in <module>
        v3 = next(f) #输出至下一个yield，但并没有下一个yield，抛出StopItertion异常
    StopIteration

### send与yield的切换 ###

send一个对象

*  激活生成器
 *  更改yield的返回值
 *  执行生成器里面的代码
 *  遇到yield回到调用位置

def fun():
        i = 0
        while True:
            x = yield i
            i += 1
            print('第%d次执行函数'%(i))
            print('x的值为',x)
    
    f = fun()
    next(f) #相当于f.send(Nnone) yield 0 暂停
    f.send('hello') #发送，使x的值为hello 继续执行 print print yield 2暂停
    print('--'*10)
    f.send('python') #发送，使x的值为python 继续执行 print print yield 3暂停

第1次执行函数
    x的值为 hello
    --------------------
    第2次执行函数
    x的值为 python

### 生成器生产者消费者版本(生产一个消费一个) ###

import random
    import time
    def produce(consumer):
        next(consumer)
        while True:
            item = random.randint(0,99)
            print('生产者生产了：',item)
            consumer.send(item)
            time.sleep(2)
    
    def consumer():
        while True:
            item = yield
            print('消费者消费了：',item)
    #先运行producer函数，next(consumer)激活consumer函数。执行item = yield暂停
    #返回producer，生产一个资源，send回consumer，consumer的item接收并输出
    c = consumer()
    produce(c)

生产者生产了： 9
    消费者消费了： 9
    生产者生产了： 28
    消费者消费了： 28
    生产者生产了： 19
    消费者消费了： 19
    生产者生产了： 8
    消费者消费了： 8

### 注意事项 ###

*  携程是在一个线程内的执行的，本质来说就是不同函数之间的切换调用。
 *  对一个生成器必须要先next()让他执行到yield才能在send数据进去。
 *  如果某一个协程被阻塞了，整个线程(进程)都被阻塞。任意时刻，只有一个协程在执行。

**2.greenlet协程**

### 由来 ###

虽然CPython（标准Python）能够通过生成器来实现协程，

但使用起来还并不是很方便。 与此同时，Python的一个衍生版 Stackless Python

实现了原生的协程，它更利于使用。 于是，大家开始将 Stackless 中关于协程的代码

单独拿出来做成了CPython的扩展包。 这就是 greenlet 的由来，因此 greenlet 是底层实现了原生协程的 C扩展库。

### 基本使用 ###

import greenlet 导入

c = greenlet.greenlet() 创建协程

c.switch() 运行c协程

import greenlet
    
    import random
    def produce():
        while True:
            item = random.randint(0,99)
            print("produce ",item)
            c.switch(item) #将data传给c，并切换到c
    def consume():
        while True:
            item = p.switch() #切换到p，等待传入数值
            print("consume ",item)
    
    c= greenlet.greenlet(consume) #将普通函数函数变成协程
    p= greenlet.greenlet(produce)
    c.switch() #运行p(消费者)协程 谁switch就运行谁

produce  6
    consume  6
    produce  63
    consume  63
    produce  1
    consume  1

### greenlet 的价值 ###

*  价值一： 高性能的原生协程
 *  价值二： 语义更加明确的显式切换
 *  价值三： 直接将函数包装成协程，保持原有代码风格

**3.gevent协程**

### gevent是什么 ###

虽然，我们有了 基于 epoll 的回调式编程模式，但是却难以使用。

即使我们可以通过配合 生成器协程 进行复杂的封装，以简化编程难度。

但是仍然有一个大的问题： 封装难度大，现有代码几乎完全要重写 。

gevent通过封装了 libev（基于epoll） 和 greenlet 两个库。

帮我们做好封装，允许我们以类似于线程的方式使用协程。

以至于我们几乎不用重写原来的代码就能充分利用 epoll 和 协程 威力。

### gevent的价值 ###

*  价值一： 使用基于 epoll 的 libev 来避开阻塞
 *  价值二： 使用基于 gevent 的 高效协程 来切换执行。遇到阻塞就切换到另一个协程继续运行
 *  价值三： 只在遇到阻塞的时候切换， 没有轮需的开销，也没有线程的开销

### genent并发服务器 ###

import genent 导入

gevent.spawn(参数) 创建协程

**服务端**

from gevent import monkey;monkey.patch_socket()
    import gevent
    import  socket
    
    sock= socket.socket()
    sock.bind(('',8088))
    sock.listen(10)
    
    def worker(con):
        while True:
            try:
                data = con.recv(1024)
                if data:
                    print(data)
                    con.send(data)
                else:
                    con.close()
                    break
            except Exception as e:
                print(e)
                break
    while True:
        con,addr=sock.accept()
        gevent.spawn(worker,con) #创建协程并传入参数con

**客户端**

import socket
    
    client = socket.socket()
    
    client.connect(('127.0.0.1',8088))
    
    while True:
        data = input('please write the message:')
        client.send(data.encode())
        print(client.recv(1024))
        if data == 'Q' or data == 'q':
            break
    
    client.close()

**4.gevent通信**

### 问题引入 ###

问： 协程之间不是能通过switch通信嘛？

答：是的，由于 gevent 基于 greenlet，所以可以。

问： 那为什么还要考虑通信问题？

答：因为 gevent 不需要我们使用手动切换， 而是遇到阻塞就切换，因此我们不会去使用switch ！

### gevent生产者消费者 ###

gevent.joinall( \[ 协程列表\] )         gevent协程运行列表

from gevent.queue import Queue           使用gevent队列

import gevent
    from gevent.queue import Queue
    import random
    
    def Consume(queue):
            while True:
                item=queue.get()
                print("消费者，消费:%s"%item)
    def Produce(queue):
            while True:
                item = random.randint(0,99)
                queue.put(item)
                print("生产者，生产：%s"%item)
    queue = Queue(3)
    
    p=gevent.spawn(Produce,queue)
    c=gevent.spawn(Consume,queue)
    gevent.joinall([p,c])

生产者，生产：58
    生产者，生产：43
    生产者，生产：17
    消费者，消费:58
    消费者，消费:43
    消费者，消费:17
    生产者，生产：8
    生产者，生产：56
    生产者，生产：65