协程

最新推荐文章于 2024-09-15 13:30:00 发布

原创最新推荐文章于 2024-09-15 13:30:00 发布 · 245 阅读

1 ·

CC 4.0 BY-SA版权

并发编程专栏收录该内容

12 篇文章

订阅专栏

协程：是单线程下的并发，又称微线程，纤程。英文名Coroutine。一句话说明什么是线程：协程是一种用户态的轻量级线程，即协程是由用户程序自己控制调度的。协程的本质就是在单线程下，由用户自己控制一个任务遇到io阻塞了就切换另外一个任务去执行，以此来提升效率。（多线程与多进程是抢占式的，协程是协作式的）

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

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

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

优点如下：
1. 协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级

2. 单线程内就可以实现并发的效果，最大限度地利用cpu

缺点如下：
1. 协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程

2. 协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程

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

用yield实现

import time
def customer(name):
    print('%s is ready to eat baozi...'%name)
    while 1:
        baozi=yield
        print('customer %s is eating baozi[%s]'%(name,baozi))
        time.sleep(1)
def producer():
    c1.__next__()
    c2.__next__()
    n=0
    while n<=10:
        print('producer is making baozi...')
        time.sleep(1)
        print('\033[1;32m[producer]\033[0m make baozi[%s] and baozi[%s]'%(n,n+1))
        c1.send(n)
        c2.send(n+1)
        n+=2
if __name__ == '__main__':
    c1=customer('alex')
    c2=customer('bart')
    producer()

用yield实现协程时，遇到io时，仍然会阻塞在原地

如果线程多的话，用yield将非常麻烦于是我们可以使用greenlet模块

Greenlet

from greenlet import greenlet#导入模块，如果不存在需要下载

def eat(name):
    print('%s eat 1'%name)
    gr2.switch('bart') #转换到gr2
    print('%s eat 2'%name)
    gr2.switch()

def play(name):
    print('%s play 1'%name)
    gr1.switch()   #转换到gr1
    print('%s play 2'%name)

if __name__ == '__main__':
    gr1=greenlet(eat)#传入要转换的函数
    gr2=greenlet(play)
    gr1.switch('alex')#可以在第一次switch时传入参数，以后都不需要
'''
alex eat 1
bart play 1
alex eat 2
bart play 2
'''

单纯的切换（在没有io的情况下或者没有重复开辟内存空间的操作），反而会降低程序的执行速度

import time

def a():
    n=1
    for i in range(100000):
        n+=i
def m():
    n=1
    for i in range(100000):
        n*=i

s=time.time()
a()
m()
e=time.time()
print('串行时间为：',e-s)


from greenlet import greenlet
def a():
    n=1
    for i in range(100000):
        n+=i
        g2.switch()
def m():
    n=1
    for i in range(100000):
        n*=i
        g1.switch()
g1=greenlet(a)
g2=greenlet(m)
s=time.time()
g1.switch()
e=time.time()
print('协程时间为：',e-s)
'''
串行时间为： 0.03602457046508789
协程时间为： 0.11908483505249023
'''

greenlet只是提供了一种比generator更加便捷的切换方式，当切到一个任务执行时如果遇到io，那就原地阻塞，仍然是没有解决遇到IO自动切换来提升效率的问题。
单线程里的这20个任务的代码通常会既有计算操作又有阻塞操作，我们完全可以在执行任务1时遇到阻塞，就利用阻塞的时间去执行任务2。。。。如此，才能提高效率，这就用到了Gevent模块。

Gevent

import gevent

def eat(name):
    print('%s eat 1'%name)
    gevent.sleep(2)
    print('%s eat 2'%name)

def play(name):
    print('%s play 1'%name)
    gevent.sleep(1)
    print('%s play 2'%name)

#g1=gevent.spawn(func,1,,2,3,x=4,y=5)创建一个协程对象g1，spawn括号内第一个参数是函数名，如eat，后面可以有多个参数，可以是位置实参或关键字实参，都是传给函数eat的
g1=gevent.spawn(eat,'alex')
g2=gevent.spawn(play,'bart')
gevent.joinall([g1,g2])#相当于g1.join();g2.join()
print('end...')
'''
alex eat 1
bart play 1
bart play 2
alex eat 2
end...
'''

上例gevent.sleep(2)模拟的是gevent可以识别的io阻塞,
而time.sleep(2)或其他的阻塞,gevent是不能直接识别的需要用下面一行代码,打补丁,就可以识别了
from gevent import monkey;monkey.patch_all()必须放到被打补丁者的前面，如time，socket模块之前
或者我们干脆记忆成：要用gevent，需要将from gevent import monkey;monkey.patch_all()放到文件的开头

from gevent import monkey;monkey.patch_all()
import gevent,time

def eat(name):
    print('%s eat 1'%name)
    time.sleep(2)
    print('%s eat 2'%name)

def play(name):
    print('%s play 1'%name)
    time.sleep(1)
    print('%s play 2'%name)

#g1=gevent.spawn(func,1,,2,3,x=4,y=5)创建一个协程对象g1，spawn括号内第一个参数是函数名，如eat，后面可以有多个参数，可以是位置实参或关键字实参，都是传给函数eat的
g1=gevent.spawn(eat,'alex')
g2=gevent.spawn(play,'bart')
gevent.joinall([g1,g2])#相当于g1.join();g2.join()
print('end...')
'''
alex eat 1
bart play 1
bart play 2
alex eat 2
end...
'''

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.python.org/'),
    gevent.spawn(get_page,'https://www.baidu.com/'),
    gevent.spawn(get_page,'https://github.com/'),
])
stop_time=time.time()
print('run time is %s' %(stop_time-start_time))
'''
GET: https://www.python.org/
GET: https://www.baidu.com/
GET: https://github.com/
2443 bytes received from https://www.baidu.com/
53719 bytes received from https://github.com/
49273 bytes received from https://www.python.org/
run time is 2.2591280937194824
'''