协程

概要：
    协程(Coroutine)，又称微线程，纤程。即协程是一种用户态的轻量级线程。
        轻量级：实质上不是利用CPU轮询执行，而是用一个线程进行切换，无需CPU控制（因此协程说白了是一个单线程）
        用户态：程序员自己控制什么时候切换。由于是利用串行，便不存在锁了（也不会有数据不安全的情况），因此协程好用的多。

    协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。
    因此：
        协程能保留上一次调用时的状态（即所有局部状态的一个特定组合），下次激活时，可以进入上一次，即调用前的状态，换种说法：进入上一次
        离开时所处逻辑流的位置。

    程序执行时在多个函数中也是顺序执行的，当一个函数遇到IO阻塞时，CPU停止了工作岂不白白消耗了资源，因此可以利用开辟其他线程的方式来使CPU进
    行并发执行，从而达到合理利用CPU的效果。但是启动线程过多，（上下文）也会消耗大量资源，还有处理锁等等（因为线程控制CPU按时间片轮询执
    行，需要加锁控制保证部分操作不冲突），此时便使用协程的方式，在一个线程内通过对io阻塞的检测，让程序员自己控制CPU的切换，合理利用CPU的资源。

一、协程的好处：
    1.无需像线程一样需要上下文切换的开销 
    2.无需原子操作锁定及同步的开销
    　　"原子操作(atomic operation)是不需要synchronized(同步)的"，所谓原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一
        直运行到结束，中间不会有任何 context switch （上下文切换：切换到另一个线程）。原子操作可以是一个步骤，也可以是多个操作步骤，但是
        其顺序是不可以被打乱，或者切割掉只执行部分。视作整体是原子性的核心。
    3.方便切换控制流，简化编程模型
    4.高并发+高扩展性+低成本：一个CPU支持上万的协程都不是问题（理论无限大）。所以很适合用于高并发处理。（因此利用的好完全可以替代线程，效率奇高）

二、缺点：
    1.无法利用多核资源：协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上.当然我们日常所编写
        的绝大部分应用都没有这个必要，除非是cpu密集型应用。
    2.进行阻塞（Blocking）操作（如IO时）会阻塞掉整个程序

三、协程的标准，即符合什么条件就能称之为协程：

    1.必须在只有一个单线程里实现并发
    2.修改共享数据不需加锁
    3.用户程序里自己保存多个控制流的上下文栈
    4.一个协程遇到IO操作自动切换到其它协程

四、协程的实现：
    1.通过yield实现的协程：（最底层的协程）

　　　　通过while循环 + yield实现生产者和消费者。 yield暂且理解为可以能够保存上下文的return。

class Productor:
    def __init__(self, name):
        self.name = name

    def run(self, c1, c2):
        c1.send(None)
        c2.send(None)
        n = 0
        while n < 5:
            n += 1
            print("\033[32;1m%s做了第%s个包子\033[0m:" % (self.name, n))
            c1.send(n)
            c2.send(n)


class Consumer:
    def __init__(self, name):
        self.name = name

    def run(self):
        print("%s准备吃包子了!" % self.name)
        while True:
            count = yield
            print("%s吃了第%s个包子" % (self.name, count))


if __name__ == '__main__':
    c1 = Consumer("c1").run()  # 在这里创建生成器对象，调用消费者的run方法
    c2 = Consumer("c2").run()

    p = Productor("p1")
    p.run(c1, c2)

  　　　　每次生产者调用run方法时进入while循环，Python的赋值运算符先计算右边，因此yeild就直接return。生产者走到c1.send(None)时，消费者打印准备吃包子。

  　　　　当下一次调用yield会记住上次未完成的结果，并接收消费者再次调用send(n)的n值赋值给count。之后执行c1吃了第一个包子....以此类推。

　　　　这就是基于yield（利用yield能保持上下文的特性）来实现两个任务之间的切换，这个切换不是线程CPU的切换而是执行顺序的切换。

　　2.通过Greenlet来实现协程：
   　　 greenlet是一个用C实现的协程模块，相比与python自带的yield，它可以使你在任意函数之间随意切换，而不需把这个函数先声明为generator（生成器）
　　

from greenlet import greenlet


def test1():
    print(1)
    gr2.switch()
    print(3)
    gr2.switch()


def test2():
    print(2)
    gr1.switch()
    print(4)


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

　   　　 创建greenlet对象来封装任务test1和test2，此时它不会执行这个函数而是创建了greenlet这个对象。当对象.switch()时就开始进行了调用（如同next）

  　　  在test1中又调用另一个greenlet对象.switch()则切换到另一个函数test2进行执行。

   　　 感觉确实用着比generator还简单了呢，但好像还没有解决一个问题，就是遇到IO操作的时候，如何能让程序自己自动切换

　　3.通过Gevent来实现协程：

    　　首先先在setting里面Project Interpreter的package（用于查看已有的库）安装gevent库 --pycharm 或是通过pip安装

import gevent, time


def Aoo():
    print("Aoo Start!", time.ctime())
    gevent.sleep(2)
    print("Aoo End..", time.ctime())


def Boo():
    print("Boo Start!", time.ctime())
    gevent.sleep(2)
    print("Boo End..", time.ctime())


Aoo()
Boo()#若利用串行执行的话，耗时4s
gevent.joinall([
    gevent.spawn(Aoo),
    gevent.spawn(Boo)
])  # gevent开启协程只需2s

　　　   Gevent 通过.sleep（仿照time.sleep让CPU睡眠）模拟，通过.spawn(方法名)的方式来生成Greenlet对象，通过.joinall([])的方式放到列表里, 或是.join() 　　
　　　　当程序遇到sleep时，会进行自动切换（即IO阻塞自动切换，此时空闲的CPU得到合理利用） 　　
　　　　gevent库下有monkey补丁，用来最大程度监听IO阻塞，爬网页可利用(正常情况都是在linux下运行)

　　　　Gevent 是一个第三方库，可以轻松通过gevent实现并发同步或异步编程，在gevent中用到的主要模式是Greenlet, 它是以C扩展模块形式接入Python的轻 　　
　　　　量级协程。 Greenlet全部运行在主程序操作系统进程的内部，但它们被协作式地调度。

 　　4.协程实现socket通信：

　　　　服务端和客户端进行socket通信：正常情况，服务端保持和客户端通信会while True：循环监听客户端发送的请求，此时若客户端没有发送请求则IO阻塞。

　　　　此时第二个客户端也不能服务器进行连接，只有当第一个客户端中断后，才会服务下一个客户端。

　　server端：

import time, gevent, socket

from gevent import socket, monkey

monkey.patch_all()


def start_server(port):
    sk = socket.socket()
    sk.bind(("127.0.0.1", port))
    sk.listen(500)

    while True:
        conn, addr = sk.accept()
        print("client accept address:", addr)
        gevent.spawn(handle_request, conn)  # 每次连接成功都创建一个Greenlet对象
        

def handle_request(conn):
    try:
        while True:
            data = conn.recv(1024)
            print("Received:", repr(data))
            conn.send(data)
    except Exception as e:
        print(e)
    finally:
        conn.close()


start_server(8004)

　　Client端：

import socket


def start_client():
    sk = socket.socket()
    sk.connect(("127.0.0.1", 8004))

    while True:
        msg = bytes(input(">>>"), encoding="utf-8")

        sk.sendall(msg)
        data = sk.recv(1024)
        print("Received:", str(data, "utf-8"))
    sk.close()


start_client()

　　　　Gevent可以在第一个客户端和服务器处于阻塞状态时，自动检测IO并进行切换，让服务器和第二个客户端进行连接、通信。

　 并发100个 socket连接：

import threading


def sock_conn():
    client = socket.socket()

    client.connect(("127.0.0.1", 8004))
    count = 0
    while True:
        client.send(("hello %s" % count).encode("utf-8"))

        data = client.recv(1024)

        print("[%s]recv from server:" % threading.get_ident(), data.decode())  
        count += 1
    client.close()


for i in range(100):
    t = threading.Thread(target=sock_conn)
    t.start()

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有