菜单

Python 协程,python协程

2019年5月12日 - Java
概要:
    协程(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)

Python 协程,python协程

假诺 Python
书籍有自然的点拨意义,那么(协程正是)文档最贫乏、最不为人知的 Python
性格,因而表面上看是最无用的风味。

                                                ——David
Beazley

                                                
  Python 图书小编

 

  字典为动词“to yield”给出了多个释义:产出和妥洽。对于 Python
生成器中的 yield 来讲,那五个意思都建设构造。yield item
那行代码会并发3个值,提供给 next(…)
的调用方;别的,还会作出迁就,暂停实践生成器,让调用方继续做事,直到须要采用另贰个值时再调用next()。调用方会从生成器中拉取值。

  从句法上看,协程与生成器类似,都以定义体中含有 yield
关键字的函数。可是,在协程中,yield 平常出现在表明式的左边(比方,datum
= yield),能够产出值,也足以不出新——倘诺yield关键字背后未有表达式,那么生成器产出
None。协程可能会从调用方接收数据,但是调用方把多少提须要协程使用的是
.send(datum) 方法,而不是 next(…) 函数。常常,调用方会把值推送给协程。

  yield 关键字依旧还足以不收受或传播数据。不管多少怎么着流动,yield
都以一种流程序调节制工具,使用它能够完结合作式多职务:协程能够把调整器妥洽给宗旨调治程序,从而激活其他的协程。

  从根本上把 yield 视作决定流程的主意,那样就好精晓协程了。

 

生成器怎样进步成协程

  协程的最底层架构在“PEP 34二—Coroutines via EnhancedGenerators”(https://www.python.org/dev/peps/pep-0342/)中定义,并在Python 2.伍(200陆年)达成了。自此之后,yield 关键字能够在表明式中运用,而且生成器 API
中扩展了 .send(value) 方法。生成器的调用方能够动用 .send(…)
方法发送数据,发送的数据会成为生成器函数中 yield
表达式的值。由此,生成器能够看成协程使用。协程是指1个进程,这一个历程与调用方合作,产出由调用方提供的值。

  除了 .send(…) 方法,PEP 34二 还增添了 .throw(…) 和
.close()方法:前者的成效是让调用方抛出13分,在生成器中管理;后者的职能是结束生成器。

 

作为协程的生成器的着力表现

举个

http://www.bkjia.com/Pythonjc/1224123.htmlwww.bkjia.comtruehttp://www.bkjia.com/Pythonjc/1224123.htmlTechArticlePython 协程,python协程 假诺 Python
书籍有必然的点拨意义,那么(协程就是)文档最贫乏、最无人问津的 Python
个性,因而表面上看是最无用…

 
    每趟生产者调用run方法时进入while循环,Python的赋值运算符先总计右侧,因而yeild就间接return。生产者走到c1.send(None)时,消费者打字与印刷打算吃包子。

 
    当下3次调用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对象来封装职责test一和test贰,此时它不会施行这些函数而是创设了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(方法名)的方法来生成格林let对象,通过.joinall([])的点子放置列表里,
或是.join()   
    当程序碰着sleep时,会进展自动切换(即IO阻塞自动切换,此时有空的CPU获得客观使用)
  
    gevent库下有monkey补丁,用来最大程度监听IO阻塞,爬网页可选用(不荒谬状态都以在linux下运作)

    Gevent
是多个第二方库,能够轻松通过gevent实现产出同步或异步编制程序,在gevent中用到的主要性形式是格林let,
它是以C扩大模块方式接入Python的轻
  
    量级协程。
格林let全体运营在主程序操作系统进度的里边,但它们被合营式地调整。

   四.协程完结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()

 

  

 

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图