Python并发编程之协程

一 概述

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

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

1. 该任务发生了阻塞
2. 该任务计算的时间过长或有一个优先级更高的程序替代了它

ps：在介绍进程时，提及进程的三种执行状态，而线程才是执行单位，所以也可以将上图理解为线程的三种状态 。

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

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

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

import time


def consumer(res):
    '''任务1:接收数据,处理数据'''
    pass

def producer():
    '''任务2:生产数据'''
    res = []
    for i in range(10000000):
        res.append(i)
    return res

start = time.time()
# 串行执行
res = producer()
consumer(res)       # 写成consumer(producer())会降低执行效率
stop = time.time()
print(stop-start)   # 1.3703606128692627

import time


def consumer():
    '''任务1:接收数据,处理数据'''
    while True:
        x = yield  # print(x)

def producer():
    '''任务2:生产数据'''
    g = consumer()
    next(g)     # 相当于g.send(None)
    for i in range(100):
        g.send(i)  # print(i)

start = time.time()
# 基于yield保存状态,实现两个任务直接来回切换,即并发的效果
# PS:如果每个任务中都加上打印,那么明显地看到两个任务的打印是你一次我一次,即并发执行的
producer()
stop = time.time()
print(stop-start)   # 1.529564619064331

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

import time


def consumer():
    '''任务1:接收数据,处理数据'''
    while True:
        x = yield

def producer():
    '''任务2:生产数据'''
    g = consumer()
    next(g)
    for i in range(10):
        g.send(i)
        time.sleep(1)

start = time.time()
producer()      # 并发执行,但是任务producer遇到io就会阻塞住,并不会切到该线程内的其他任务去执行

stop = time.time()
print(stop-start)   # 10.003803730010986

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

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

1. 可以控制多个任务之间的切换，切换之前将任务的状态保存下来，以便重新运行时，可以基于暂停的位置继续执行
2. 作为1的补充：可以检测io操作，在遇到io操作的情况下才发生切换

关于yield可参考另外一篇文章：Python函数之装饰器&列表生成式&迭代器&生成器

二 什么是协程

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

需要强调的是：

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

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

优点：

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

缺点：

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

总结协程特点：

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

三 greenlet

greenlet模块和yield没有什么区别，就只是单纯的切，跟效率无关。只不过比yield切的时候方便一点，但仍然没有解决效率问题。greentlet是python中实现我们所谓的"Coroutine(协程)"的一个基础库。

安装

pip3 install greenlet

from greenlet import greenlet
import time


def run(name):
    print('%s run' %name)
    # time.sleep(2)       # 遇到io，原地阻塞
    g2.switch('joe')
    print('%s run' %name)
    g2.switch()


def jump(name):
    print('%s jump' %name)
    g1.switch()
    print('%s jump' %name)

g1 = greenlet(run)
g2 = greenlet(jump)

g1.switch('joe')   # 需要传参时，在第一次switch时传入参数，以后都不需要

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

# 顺序执行
import time


def func1():
    res = 1
    for i in range(10000000):
        res += i

def func2():
    res = -1
    for i in range(10000000):
        res -= i

start = time.time()
func1()
func2()
stop = time.time()
print(stop-start)    # 1.5620343685150146


# 切换
from greenlet import greenlet
import time


def func1():
    res = 1
    for i in range(10000000):
        res += i
        g2.switch()

def func2():
    res = -1
    for i in range(10000000):
        res -= i
        g1.switch()

start = time.time()
g1 = greenlet(func1)
g2 = greenlet(func2)
g1.switch()
stop = time.time()
print(stop-start)   # 8.033021688461304

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

四 gevent

Python通过yield提供了对协程的基本支持，但是不完全。而第三方的gevent为Python提供了比较完善的协程支持。

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

当一个greenlet遇到IO操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行。由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待IO。

安装

pip3 install gevent

用法

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

g1.join()   # 等待g1结束
g2.join()   # 等待g2结束
# 或者上述两步合作一步：gevent.joinall([g1,g2])

g1.value    # 拿到func1的返回值

遇到IO阻塞时会自动切换任务

import gevent

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

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

g1 = gevent.spawn(run, 'joe')
g2 = gevent.spawn(jump, name='joe')
g1.join()
g2.join()
# gevent.joinall([g1,g2])    # 效果等价于上面两行
print('主')

上例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()
import gevent
import time


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

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

g1 = gevent.spawn(run, 'joe')
g2 = gevent.spawn(jump, name='joe')
g1.join()
g2.join()
# gevent.joinall([g1,g2])    # 效果等价于上面两行
print('主')

注意：可以使用threading.current_thread().getName()来查看每个g1和g2，查看的结果为DummyThread-n，即假线程。

五 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()
gevent.joinall([
    gevent.spawn(get_page, 'http://www.baidu.com'),
    gevent.spawn(get_page, 'https://www.yahoo.com/'),
    gevent.spawn(get_page, 'https://github.com/'),
])
stop = time.time()
print(stop-start)

from gevent import joinall,spawn,monkey;monkey.patch_all()
import requests,time
from threading import current_thread

def parse_page(res):
    print('%s parse %s bytes' %(current_thread().getName(),len(res)))

def get_page(url,callback=parse_page):
    print('%s get %s' %(current_thread().getName(),url))
    response=requests.get(url)
    if response.status_code == 200:
        callback(response.text)

if __name__ == '__main__':
    urls=[
        'https://www.baidu.com',
        'https://www.yahoo.com/',
        'https://github.com/',
    ]
    start = time.time()
    tasks = []
    for url in urls:
        tasks.append(spawn(get_page,url))
    joinall(tasks)
    stop = time.time()
    print(stop-start)

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

注意：from gevent import monkey;monkey.patch_all()一定要放到导入socket模块之前，否则gevent无法识别socket的阻塞

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

# 如果不想用money.patch_all()打补丁,可以用gevent自带的socket
# from gevent import socket
# s = socket.socket()

ip_port = ('127.0.0.1',8081)
buf_size = 1024

def tcp_server(ip_port):
    s = socket()
    s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
    s.bind(ip_port)
    s.listen(5)
    while True:
        conn,addr = s.accept()
        gevent.spawn(run, conn, addr)

def run(conn,addr):
    try:
        while True:
            res = conn.recv(buf_size)
            print('client %s:%s msg: %s' %(addr[0],addr[1],res.decode('utf8')))
            conn.send(res.upper())
    except Exception as e:
        print(e)
    finally:
        conn.close()

if __name__ == '__main__':
    print('The server is ready...')
    tcp_server(ip_port)

import socket

ip_port = ('127.0.0.1',8081)
buf_size = 1024

tcp_client = socket.socket()
tcp_client.connect(ip_port)

while True:
    send_msg = input('>>: ').strip()
    if not send_msg:continue
    tcp_client.send(send_msg.encode('utf-8'))
    recv_msg = tcp_client.recv(buf_size)
    print(recv_msg.decode('utf-8'))

from threading import Thread
import socket
import threading

ip_port = ('127.0.0.1',8081)
buf_size = 1024

def tcp_client(ip_port):
    c = socket.socket() # 套接字对象一定要加到函数内，即局部名称空间内，放在函数外则被所有线程共享，则大家公用一个套接字对象，那么客户端端口永远一样了
    c.connect(ip_port)
    count = 1
    while True:
        c.send('hello'.encode('utf-8'))
        recv_msg = c.recv(buf_size)
        print(recv_msg.decode('utf-8'))
        count += 1

if __name__ == '__main__':
    for i in range(100):
        t = Thread(target=tcp_client,args=(ip_port,))
        t.start()

七 eventlet(了解)

eventlet 是基于 greenlet 实现的面向网络应用的并发处理框架，提供“线程”池、队列等与其他 Python 线程、进程模型非常相似的 api，并且提供了对 Python 发行版自带库及其他模块的超轻量并发适应性调整方法，比直接使用 greenlet 要方便得多。

其基本原理是调整 Python 的 socket 调用，当发生阻塞时则切换到其他 greenlet 执行，这样来保证资源的有效利用。需要注意的是：
eventlet 提供的函数只能对 Python 代码中的 socket 调用进行处理，而不能对模块的 C 语言部分的 socket 调用进行修改。对后者这类模块，仍然需要把调用模块的代码封装在 Python 标准线程调用中，之后利用 eventlet 提供的适配器实现 eventlet 与标准线程之间的协作。
虽然 eventlet 把 api 封装成了非常类似标准线程库的形式，但两者的实际并发执行流程仍然有明显区别。在没有出现 I/O 阻塞时，除非显式声明，否则当前正在执行的 eventlet 永远不会把 cpu 交给其他的 eventlet，而标准线程则是无论是否出现阻塞，总是由所有线程一起争夺运行资源。所有 eventlet 对 I/O 阻塞无关的大运算量耗时操作基本没有什么帮助。

 

参考：http://www.cnblogs.com/linhaifeng/articles/7429894.html