Python基础---协程

协程原理

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

#1. python的线程属于内核级别的，即由操作系统控制调度（如果单线程遇到io或执行时间过长就会被迫交出cpu执行权限，
切换到其他线程运行）
#2. 单线程内开启协程，一旦遇到io，就会从应用程序级别（而非操作系统）控制切换，以此来提升效率
（！！！非io操作的切换与效率无关）

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

优点：

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

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

缺点：

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

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

协程特点:

　　必须在只有一个单线程中实现并发

　　修改共享数据时不用加锁

　　用户程序中自己保存多个控制流的上下文栈

　　附加：一个协程遇到IO操作自动切换到其它协程(如何实现检测IO，yield、greenlet都无法实现，就用到了gevent模块)(select机制)

线程和协程的区别:

　　线程: 在CPython解释器中,线程只能利用单核,并且只有存在IO操作的多个任务才适合开启多线程

　　协程: 在一个线程内可以放多个任务,多个任务的执行状态还可以切换

多个任务之间切换

生成器函数,本身就是一个协程:

　　asyncio, 使用yield关键字实现规避IO的操作

　　tornado框架, 也是利用yield实现了异步框架的效果

运用原生的yield可以写一个协程,会造成一些时间上的延迟,但能够记录程序执行的状态

import time
def consumer():    # 消费者
    while 1:            # 先生产,再消费
        goods = yield
        time.sleep(1)              # IO阻塞
        print(goods)
def producer():    # 生产者
    c = consumer()
    next(c)
    for i in range(10):
        c.send('包子%s'% i )      # 生产并发送了一个数据
producer()

原生yield

import time
# 串行执行                  效率略高于   基于yield实现的并发
def consumer(res):
    pass
def producer():
    res = []
    for i in range(1000000):
        res.append(i)
    return res
start = time.time()
res = producer()
consumer(res)
print(time.time() - start)

# 基于yield的并发执行
import time
def consumer():
    while 1:
        x = yield
def producer():
    c = consumer()
    next(c)
    for i in range(1000000):
        c.send(i)
start = time.time()
producer()
print(time.time() - start)

效率测试

greenlet扩展模块

greenlet模块安装:  pip3 install greenlet

from greenlet import greenlet

def eat():
    print('开吃')
    g2.switch()       # 开启协程g2,会执行完g2,但g1的end不会执行
    time.sleep(1)
    print('吃完了')
    
def sleep():
    print('睡觉')
    time.sleep(1)
    print('醒了')
    g1.switch('小胖')    # 执行完g2后,再启动协程g1,就会完全执行

g1 = greenlet(eat)
g2 = greenlet(sleep)
g1.switch()                # 启动协程g1
      

View Code

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

# 按顺序执行
import time
def f1():
    res=1
    for i in range(100000000):
        res += i

def f2():
    res=1
    for i in range(100000000):
        res *= i

start=time.time()
f1()
f2()
stop=time.time()
print('run time is %s' %(stop-start)) #10.985628366470337

# 切换执行
from greenlet import greenlet
import time
def f1():
    res=1
    for i in range(100000000):
        res += i
        g2.switch()

def f2():
    res=1
    for i in range(100000000):
        res *= i
        g1.switch()

start=time.time()
g1=greenlet(f1)
g2=greenlet(f2)
g1.switch()
stop=time.time()
print('run time is %s' %(stop-start)) # 52.763017892837524

效率对比

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

单线程中的这20个任务的代码一般情况下会有计算和阻塞操作，我们完全可以在执行任务1时遇到阻塞就执行任务2，只有这样才能提高效率，这就可以利用到Gevent模块。

gevent模块

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

用法

g1=gevent.spawn(func,1,2,3,x=4,y=5)创建一个协程对象g1，spawn括号内第一个参数是函数名，如eat，后面可以有
多个参数，可以是位置实参或关键字实参，都是传给函数eat的

g2=gevent.spawn(func2)

g1.join() #等待g1结束

g2.join() #等待g2结束

#也可以两步合作一步：gevent.joinall([g1,g2])

g1.value#拿到func1的返回值

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(eat,'小胖')
g2=gevent.spawn(play,name='小胖')
gevent.joinall([g1,g2])
print('主')

遇到IO自动切换

上例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
import time
def eat():
    print('eat food 1')
    time.sleep(2)
    print('eat food 2')

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

g1=gevent.spawn(eat)
g2=gevent.spawn(play)
gevent.joinall([g1,g2])
print('主')

from gevent import monkey

我们可以通过threading.current_thread().getName()来查看每个g1和g2, 查看的结果为DummyThread-n，即假线程

from gevent import monkey;monkey.patch_all()
import threading
import gevent
import time
def eat():
    print(threading.current_thread().getName())
    print('eat food 1')
    time.sleep(2)
    print('eat food 2')

def play():
    print(threading.current_thread().getName())
    print('play 1')
    time.sleep(1)
    print('play 2')

g1=gevent.spawn(eat)
g2=gevent.spawn(play)
gevent.joinall([g1,g2])
print('主')

*******
结果:
DummyThread-1
eat food 1
DummyThread-2
play 1
play 2
eat food 2
主

threading.current_thread().getName()

gevent之同步与异步

from gevent import monkey
monkey.patch_all()
import time

def task(pid):
    time.sleep(1)
    print('Task %s done' % pid)

def sync():  # 同步, 结果会一个一个打印出来
    for i in range(10):
        task(i)

def async(): # 异步: 同时出结果
    # g_l=[spawn(task,i) for i in range(10)]
    g_lst = []
    for i in range(10):
        g = gevent.spawn(task, i)
        g_lst.append(g)
    gevent.joinall(g_l)
    print('DONE')
    
if __name__ == '__main__':
    print('Sync')
    sync()
    print('Async')
    async()
#  上面程序的重要部分是将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.python.org/'),
    gevent.spawn(get_page,'https://www.yahoo.com/'),
    gevent.spawn(get_page,'https://github.com/'),
])
stop_time=time.time()
print('run time is %s' %(stop_time-start_time))

简单爬虫

Gevent应用场景二

通过gevent实现单线程下的socket并发

ps: from gevent import monkey ; monkey.patch_all()必须在导入socket模块之前,否则gevent模块不能识别socket模块的阻塞

from gevent import monkey
monkey.patch_all()
import socket
import gevent


def talk(conn):
    while True:
        msg = conn.recv(1024).decode()
        ret_msg = msg.upper().encode()
        conn.send(ret_msg)
sk = socket.socket() 
sk.bind(('127.0.0.1', 8000))
sk.listen(5)
while True:
    conn, addr = sk.accept()
    g = gevent.spawn(talk, conn)          # 创建一个协程对象

server端

import socket
client = socket.socket()
client.connect(('127.0.0.1', 8000))
while 1:
    client.send(b'hello')
    from_sk = client.recv(1024)
    print(from_sk)

client端

 

转载于:https://www.cnblogs.com/py8318/p/10549632.html