图片 10

协程介绍及主干示例,知识拾遗篇

协程

协程介绍及基本示例

协程,又称微线程,纤程。英文名Coroutine。一句话说明什么是协程:协程是一种用户态的轻量级线程

  协程拥有自己的寄存器上下文和栈。协程调度切换时,将寄存器上下文和栈保存到其他地方,在切回来的时候,恢复先前保存的寄存器上下文和栈。因此:

协程能保留上一次调用时的状态(即所有局部状态的一个特定组合),每次过程重入时,就相当于进入上一次调用的状态,换种说法:进入上一次离开时所处逻辑流的位置。

  协程的好处:

  • 无需线程上下文切换的开销
  • 无需原子操作锁定及同步的开销
    • “原子操作(atomic
      operation)是不需要synchronized”,所谓原子操作是指不会被线程调度机制打断的操作;这种操作一旦开始,就一直运行到结束,中间不会有任何
      context switch
      (切换到另一个线程)。原子操作可以是一个步骤,也可以是多个操作步骤,但是其顺序是不可以被打乱,或者切割掉只执行部分。视作整体是原子性的核心。
  • 方便切换控制流,简化编程模型
  • 高并发+高扩展性+低成本:一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理。

  缺点:

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

1.定义

协程,顾名思义,程序协商着运行,并非像线程那样争抢着运行。协程又叫微线程,一种用户态轻量级线程。协程就是一个单线程(一个脚本运行的都是单线程)

 协程拥有自己的寄存器上下文和栈。协程调度切换时,将寄存器上下文和栈保存到其他地方,在切回来的时候,恢复先前保存的寄存器上下文和栈。

协程能保留上一次调用时的状态(即所有局部状态的一个特定组合),每次过程重入时,就相当于进入上一次调用的状态,换种说法:进入上一次离开时所处逻辑流的位置,看到这

图片 1 

图片 2

 图片 3

 

是的,就是生成器,后面再实例更会充分的利用到生成器,但注意:生成器 !=
协程

 

 

1、yield实现协程

import time


def consumer(name):
    print("--->starting eating baozi...")
    while True:
        new_baozi = yield   # yield设置生成器
        print("[{0}] is eating baozi {1}".format(name, new_baozi))


def producer():
    r = con.__next__()  # 调用生成器
    r = con2.__next__()
    n = 0
    while n < 5:
        n += 1
        con.send(n)  # 唤醒生成器,并且向生成器传值
        con2.send(n)
        time.sleep(1)
        print("\033[32m[producer]\033[0m is making baozi {0}".format(n))

if __name__ == '__main__':
    con = consumer("c1")   # 创建一个生成器c1
    con2 = consumer("c2")   # 创建一个生产器C2
    p = producer()

1、send有两个作用?

  ①唤醒生产器
②给yield传一个值,就是yield接收到的这个值。这个说明yield在被唤醒的时候可以接收数据。

2、怎么实现我们的单线程实现并发的效果呢?

  遇到IO操作就切换,IO比较耗时,协程之所以能处理大并发,就是IO操作会挤掉大量的时间。没有IO操作的话,整个程序只有cpu在运算了,因为cpu很快,所以你感觉是在并发执行的。

3、IO操作完成了,程序什么时候切回去?

  IO操作一旦完成,我们就自动切回去。

4、IO是什么?

Python中的io模块是用来处理各种类型的I/O操作流。主要有三种类型的I/O类型:文本I/O(Text
I/O),二进制I/O(Binary I/O)和原始I/O(Raw
I/O)。它们都是通用类别,每一种都有不同的后备存储。属于这些类别中的任何一个的具体对象称为文件对象,其他常用的术语为流或者类文件对象。

  除了它的类别,每一种具体的流对象也具有各种功能:它仅仅允许读,或者仅仅允许写,或者既能读又能写。它也允许任意随机访问(向前或者向后寻找任何位置),或者仅仅顺序访问(例如在套接字或管道中)。

  所有的流对于提供给它们的数据的数据类型都很严格。例如,如果用一个二进制流的write()方法写一个字符类型的数据,那么将会触发一个TypeError错误。用文本流的write()方法来写字节对象数据也是一样的,会触发该错误。

 

2.特性

优点:

  • 无需线程上下文切换的开销
  • 无需原子操作锁定及同步的开销
  • 方便切换控制流,简化编程模型
  • 高并发+高扩展性+低成本:一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理。

注:比如修改一个数据的整个操作过程下来只有两个结果,要嘛已修改,要嘛未修改,中途出现任何错误都会回滚到操作前的状态,这种操作模式就叫原子操作,”原子操作(atomic
operation)是不需要synchronized”,不会被线程调度机制打断的操作;这种操作一旦开始,就一直运行到结束,中间不会有任何
context switch
(切换到另一个线程)。原子操作可以是一个步骤,也可以是多个操作步骤,但是其顺序是不可以被打乱,或者切割掉只执行部分。视作整体是原子性的核心。 

 

缺点:

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

二、手动实现切换IO

Greenlet是python的一个C扩展,来源于Stackless
python,旨在提供可自行调度的‘微线程’,
即协程。它可以使你在任意函数之间随意切换,而不需把这个函数先声明为generator

from greenlet import greenlet


def test1():
    print(12)
    gr2.switch()  # 切换到test2
    print(34)
    gr2.switch()   # 切换到test2


def test2():
    print(56)
    gr1.switch()   # 切换到test1
    print(78)

gr1 = greenlet(test1)  # 启动一个协程
gr2 = greenlet(test2)
gr1.switch()   # 切换到test1,这个switch不写的话,会无法输出打印

#执行结果
12
56
34
78

小结:

  1. cpu值认识线程,而不认识协程,协程是用户自己控制的,cpu根本都不知道它们的存在。
  2. 线程的上下文切换保存在cpu的寄存器中,但是协程拥有自己的寄存上下文和栈。
  3. 协程是串行的,无需锁。

虽然greenlet确实用着比generator(生成器)还简单了,但好像还没有解决一个问题,就是遇到IO操作,自动切换,对不对?

 

三、协程遇IO操作自动切换

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

import gevent


def foo():
    print("Running in foo")
    gevent.sleep(3)  # 模仿io操作,一遇到io操作就切换
    print("Explicit context switch to foo again")


def bar():
    print("Explicit context to bar")
    gevent.sleep(1)
    print("Implicit context switch back to bar")


def fun3():
    print("running fun3")
    gevent.sleep(0)   # 虽然是0秒,但是会触发一次切换
    print("running fun3 again")

gevent.joinall([
    gevent.spawn(foo),  # 生成协程
    gevent.spawn(bar),
    gevent.spawn(fun3)
])

#执行结果
Running in foo
Explicit context to bar
running fun3
running fun3 again
Implicit context switch back to bar
Explicit context switch to foo again

当foo遇到sleep(2)的时候,切自动切换到bar函数,执行遇到sleep(1)的时候自动切换到fun3函数,遇到sleep(0)又自动切换到foo。这个时候sleep(2)还没有执行完毕,又切换到bar的sleep(1)这边,发现又没有执行完毕,就有执行fun3这边,发现sleep(0)执行完毕,则继续执行,然后又切换到foo,发现sleep(2)又没有执行完毕,就切换到bar的sleep(1)这边,发现执行完了,有切回到foo这边,执行完毕。

主要作用:比如说你现在又50处IO,然后总共加起来串行的的话,要花100秒,但是50处IO最长的那个IO只花了5秒钟,那代表中你的这个程序就是协程最多5秒就执行完毕了。

符合下面四个条件才能称之为协程:

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

 

 

3.实例

协程(gevent)并发爬网页

上面例子gevent遇到io自动切换,现在就来实际演示协程爬虫的例子

 1)用生成器实现伪协程:

在这之前,相信很多朋友已经把生成器是什么忘了吧,这里简单复习一下。

创建生成器有两个放法:

A:使用列表生成器:

图片 4

 

B:使用yield创建生成器:

图片 5

 

访问生成器数据,使用next()或者__next__()方法:

图片 6

 

好的,既然说到这里,就说下,yield可以暂存数据并转发:

图片 7

 

传是传入了,但结果却报错:

图片 8

 

为什么报错呢?首先要说一个知识点,使用next()和send()方法都会取出一个数据,不同的是send即发送数据又取出上一数据,并且如果要发送数据必须是第二次发送,如果第一次就是用send,必须写为send(None)才行,不然报错。next(obj) = obj.send(None).

因为yield是暂存数据,每次next()时将会在结束时的此处阻塞住,下一次又从这里开始,而发送完,send取数据发现已经结束了,数据已经没了,所以修改报错,

那么稍作修改得:

图片 9

 

完美!

 

好的,进入正题了,有了上面的现钞,现在现卖应该没问题了:

依然是前面的生产者消费者模型 

import time
import queue

def consumer(name):
    print("--->starting eating baozi...")
    while True:
        new_baozi = yield
        print("[%s] is eating baozi %s" % (name,new_baozi))
        #time.sleep(1)

def producer():

    r = con.__next__()
    r = con2.__next__()
    n = 0
    while n < 5:
        n +=1
        con.send(n)
        con2.send(n)
        print("\033[32;1m[producer]\033[0m is making baozi %s" %n )


if __name__ == '__main__':
    con = consumer("c1")
    con2 = consumer("c2")
    p = producer()

  

运行结果:

图片 10

 

首先我们知道使用yield创建了一个生成器对象,然后每次使用时利用new_baozi做一个中转站来缓存数据。这就是实现协程效果了对吧?

前面我提了一句,yield下是伪协程,那么什么是真正的协程呢?

需要具备以下条件

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

 

1、正常(串行)爬网页

串行效果的爬网页的代码,看看消耗多长时间

from urllib import request
import time


def run(url):
    print("GET:{0}".format(url))
    resp = request.urlopen(url)    # request.urlopen()函数 用来打开网页
    data = resp.read()    # 读取爬到的数据
    with open("url.html", "wb") as f:
        f.write(data)
    print('{0} bytes received from {1}'.format(len(data), url))

urls = [
    'http://www.163.com/',
    'https://www.yahoo.com/',
    'https://github.com/'
]

time_start = time.time()    # 开始时间
for url in urls:
    run(url)
print("同步cost", time.time() - time_start)  # 程序执行消耗的时间

#执行结果
GET:http://www.163.com/
659094 bytes received from http://www.163.com/
GET:https://www.yahoo.com/
505819 bytes received from https://www.yahoo.com/
GET:https://github.com/
56006 bytes received from https://github.com/
同步cost 4.978517532348633

  

发表评论

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