1. 技术文章
  2. Python-协程

Python-协程

由 风格不统一 提交于 2020-01-20 04:14:24

一、引子

本节的主题是基于单线程来实现并发，即只用一个主线程（很明显可利用的cpu只有一个）情况下实现并发，为此我们需要先回顾下并发的本质：切换+保存状态。

cpu正在运行一个任务，会在两种情况下切走去执行其他的任务（切换由操作系统强制控制）：

  • 一种情况是该任务发生了阻塞；
  • 另外一种情况是该任务计算的时间过长或有一个优先级更高的程序替代了它。

协程本质上就是一个线程，以前线程任务的切换是由操作系统控制的，遇到I/O自动切换，现在我们用协程的目的就是较少操作系统切换的开销（开关线程，创建寄存器、堆栈等，在他们之间进行切换等），在我们自己的程序里面来控制任务的切换。

在这里插入图片描述
ps：在介绍进程理论时，提及进程的三种执行状态，而线程才是执行单位，所以也可以将上图理解为线程的三种状态

需要注意的是：

一：其中第二种情况并不能提升效率，只是为了让cpu能够雨露均沾，实现看起来所有任务都被“同时”执行的效果，如果多个任务都是纯计算的，这种切换反而会降低效率。为此我们可以基于yield来验证。yield本身就是一种在单线程下可以保存任务运行状态的方法，我们来简单复习一下：

#1 yiled 可以保存状态，yield的状态保存与操作系统的保存线程状态很像，但是yield是代码级别控制的，更轻量级
#2 send 可以把一个函数的结果传给另外一个函数，以此实现单线程内程序之间的切换

通过yield实现任务切换+保存线程：

import time

def func1():

    for i in range(11):
        #yield
        print('这是我第%s次打印啦' % i)
        time.sleep(1)


def func2():
    g = func1()
    #next(g)
    for k in range(10):

        print('哈哈，我第%s次打印了' % k)
        time.sleep(1)
        #next(g)

#不写yield，下面两个任务是执行完func1里面所有的程序才会执行func2里面的程序，有了yield，我们实现了两个任务的切换+保存状态
func1()
func2()

单纯的切换反而会降低运行效率：

#基于yield并发执行，多任务之间来回切换，这就是个简单的协程的体现，但是他能够节省I/O时间吗？不能
import time
def consumer():
    '''任务1:接收数据,处理数据'''
    while True:
        x=yield
        # time.sleep(1) #发现什么？只是进行了切换，但是并没有节省I/O时间
        print('处理了数据：',x)
def producer():
    '''任务2:生产数据'''
    g=consumer()
    next(g)  #找到了consumer函数的yield位置
    for i in range(3):
    # for i in range(10000000):
        g.send(i)  #给yield传值，然后再循环给下一个yield传值，并且多了切换的程序，比直接串行执行还多了一些步骤，导致执行效率反而更低了。
        print('发送了数据：',i)
start=time.time()
#基于yield保存状态,实现两个任务直接来回切换,即并发的效果
#PS:如果每个任务中都加上打印,那么明显地看到两个任务的打印是你一次我一次,即并发执行的.
producer() #我在当前线程中只执行了这个函数，但是通过这个函数里面的send切换了另外一个任务
stop=time.time()

# 串行执行的方式
# res=producer()
# consumer(res) 
# stop=time.time()

print(stop-start)

二：第一种情况的切换。在任务一遇到io情况下，切到任务二去执行，这样就可以利用任务一阻塞的时间完成任务二的计算，效率的提升就在于此。

yield不能检测IO，实现遇到IO自动切换：

import time

def func1():
    while True:
        print('func1')
        yield

def func2():
    g = func1()
    for i in range(10000000):
        i + 1
        next(g)
        time.sleep(3)
        print('func2')

start = time.time()
func2()
stop = time.time()
print(stop - start)

协程就是告诉Cpython解释器，你不是nb吗，不是搞了个GIL锁吗，那好，我就自己搞成一个线程让你去执行，省去你切换线程的时间，我自己切换比你切换要快很多，避免了很多的开销。

对于单线程下，我们不可避免程序中出现io操作，但如果我们能在自己的程序中（即用户程序级别，而非操作系统级别）控制单线程下的多个任务能在一个任务遇到io阻塞时就切换到另外一个任务去计算，这样就保证了该线程能够最大限度地处于就绪态，即随时都可以被cpu执行的状态，相当于我们在用户程序级别将自己的io操作最大限度地隐藏起来，从而可以迷惑操作系统，让其看到：该线程好像是一直在计算，io比较少，从而更多的将cpu的执行权限分配给我们的线程。

协程的本质就是在单线程下，由用户自己控制一个任务遇到io阻塞了就切换另外一个任务去执行，以此来提升效率。为了实现它，我们需要找寻一种可以同时满足以下条件的解决方案：

  • 可以控制多个任务之间的切换，切换之前将任务的状态保存下来，以便重新运行时，可以基于暂停的位置继续执行。

  • 作为1的补充：可以检测io操作，在遇到io操作的情况下才发生切换

二、协程介绍

协程：是单线程下的并发，又称微线程，纤程。英文名Coroutine。一句话说明什么是协程：协程是一种用户态的轻量级线程，即协程是由用户程序自己控制调度的。

需要强调的是：

  • python的线程属于内核级别的，即由操作系统控制调度（如单线程遇到io或执行时间过长就会被迫交出cpu执行权限，切换其他线程运行）

  • 单线程内开启协程，一旦遇到io，就会从应用程序级别（而非操作系统）控制切换，以此来提升效率（！！！非io操作的切换与效率无关）

对比操作系统控制线程的切换，用户在单线程内控制协程的切换
优点：

  1. 协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
  2. 单线程内就可以实现并发的效果，最大限度地利用cpu

缺点：

  1. 协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程
  2. 协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程

总结协程的特点：

  • 必须在只有一个单线程里实现并发
  • 修改共享数据不需加锁
  • 用户程序里自己保存多个控制流的上下文栈
  • 附加：一个协程遇到IO操作自动切换到其它协程（如何实现检测IO，yield、greenlet都无法实现，就用到了gevent模块（select机制））

三、Greenlet

如果我们在单个线程内有20个任务，要想实现在多个任务之间切换，使用yield生成器的方式过于麻烦（需要先得到初始化一次的生成器，然后再调用send… 非常麻烦），而使用greenlet模块可以非常简单地实现这20个任务直接的切换。

安装：

pip3 install greenlet
conda install greenlet

使用：

# 使用greenlet完成协程
import time
from greenlet import greenlet


def taskA():
    for i in range(5):
        print('A'+str(i))
        gb.switch()
        time.sleep(0.2)

def taskB():
    for i in range(5):
        print('B'+str(i))
        gc.switch()
        time.sleep(0.2)

def taskC():
    for i in range(5):
        print('C'+str(i))
        ga.switch()
        time.sleep(0.2)


if __name__ == '__main__':
    ga = greenlet(taskA)
    gb = greenlet(taskB)
    gc = greenlet(taskC)

    ga.switch()

输出：

A0
B0
C0
A1
B1
C1
A2
B2
C2
A3
B3
C3
A4
B4
C4

greenlet只是提供了一种比generator更加便捷的切换方式，当切到一个任务执行时如果遇到IO，那就原地阻塞，仍然是没有解决遇到IO自动切换来提升效率的问题。

四、Gevent模块

greenlet已经实现了协程，但是这个人工切换，是不是觉得太麻烦了。不要着急，python还有一个比greenlet更强大的并且能够自动切换任务的模块gevent

其原理是当一个greenlet遇到IO（指的是input output输入输出，比如网络、文件操作等）操作时，比如访问网络，就自动切换到其他的greenlet，等待IO完成，在适当的时候切换回来继续执行。

由于IO操作非常耗时，经常使程序处于等待状态，有了gevent我们自动切换协程，就保证总有greenlet在执行，而不是等待IO

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

安装：

pip3 install gevent
conda install gevent

用法（遇到IO阻塞时会自动切换任务）：

import gevent
from gevent import monkey
monkey.patch_all()

import time


def taskA():
    for i in range(5):
        print('A'+str(i))
        time.sleep(0.2)

def taskB():
    for i in range(5):
        print('B'+str(i))
        time.sleep(0.2)

def taskC():
    for i in range(5):
        print('C'+str(i))
        time.sleep(0.2)


if __name__ == '__main__':
    ga = gevent.spawn(taskA)
    gb = gevent.spawn(taskB)
    gc = gevent.spawn(taskC)

    ga.join()
    gb.join()
    gc.join()

    print('---'*10)

输出：

A0
B0
C0
A1
C1
B1
A2
B2
C2
A3
C3
B3
A4
B4
C4
------------------------------

gevent.sleep(0.2)模拟的是gevent可以识别的io阻塞;

而time.sleep(2)或其他的阻塞,gevent是不能直接识别的需要用下面一行代码,打补丁,就可以识别了

from gevent import monkey;
monkey.patch_all() #必须放到被打补丁者的前面，如time，socket模块之前

或者我们干脆记忆成：要用gevent，需要将from gevent import monkey;monkey.patch_all()放到文件的开头

五、Gevent之同步与异步

协程：同步与异步对比

from gevent import spawn, joinall, monkey

monkey.patch_all()
                 
import time

def task(pid):
    """
    Some non-deterministic task
    """
    time.sleep(0.5)
    print('Task %s done' % pid)

def synchronous():
    for i in range(10):
        task(i)

def asynchronous():
    g_l = [spawn(task, i) for i in range(10)]
    joinall(g_l)

if __name__ == '__main__':
    print('Synchronous:')
    synchronous()

    print('Asynchronous:')
    asynchronous()

上面程序的重要部分是将task函数封装到Greenlet内部线程的gevent.spawn。 初始化的greenlet列表存放在数组threads中，此数组被传给gevent.joinall 函数，后者阻塞当前流程，并执行所有给定的greenlet。执行流程只会在 所有greenlet执行完后才会继续向下走。

六、Gevent之应用-爬虫

协程在爬虫上的应用：

# 协程在爬虫上的应用
from gevent import monkey

monkey.patch_all()

import gevent
import requests
import time

def get_page(url):
    print('GET: %s' % url)
    response = requests.get(url)
    if response.status_code == 200:
        print('%d bytes received from %s' % (len(response.text), url))

start_time = time.time()
gevent.joinall([
    gevent.spawn(get_page, 'https://www.baidu.com/'),
    gevent.spawn(get_page, 'https://www.sogou.com/'),
    gevent.spawn(get_page, 'https://github.com/'),
])
stop_time = time.time()
print('run time is %s' % (stop_time - start_time))

print('--------------------------------')
s = time.time()
requests.get('https://www.baidu.com/')
requests.get('https://www.sogou.com/')
requests.get('https://github.com/')
t = time.time()
print('串行时间>>',t-s)  # run time is 2.5960400104522705

输出：

GET: https://www.baidu.com/
GET: https://www.sogou.com/
GET: https://github.com/
2443 bytes received from https://www.baidu.com/
18075 bytes received from https://www.sogou.com/
126134 bytes received from https://github.com/
run time is 1.4175119400024414
--------------------------------
串行时间>> 1.3217756748199463

参考资料：Python之协程

标签
gevent
协程
python协程
线程阻塞
python多线程
线程
单线程
python
yield
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!