gevent学习之路

前言：最近转技术栈，需要学习Python的gevent框架，为了能看懂怎么用DAG图来优化复杂并有依赖关系的初始化。我寻思这不就是Java的CompletableFuture功能吗，只不过Python对于多线程的支持不太好，所以才需要引入gevent框架。

一、Python协程

学习gevent之前，就得先了解一下Python原生协程的支持，以及它的局限性以及不完善，要不也不需要引入框架嘛。

协程与线程

线程是操作系统级别的调用，线程切换时需要操作系统，保存线程的上下文。
协程程序级别的调用，协程何时需要切换，是由程序员决定的。协程上下文切换的开销更小，而且不需要解决线程安全问题。
我们可以分别用协程和线程写消费者与生产者对比下：
协程实现：

def consumer():
    r = ''
    while True:
        n = yield r
        if not n:
            return
        print('[CONSUMER] Consuming %s...' % n)
        r = '200 OK'

def produce(c):
    c.send(None)
    n = 0
    while n < 5:
        n = n + 1
        print('[PRODUCER] Producing %s...' % n)
        r = c.send(n)
        print('[PRODUCER] Consumer return: %s' % r)
    c.close()

c = consumer()
produce(c)

线程实现，参考这篇博客：
https://blog.csdn.net/ldx19980108/article/details/81707751
对比两种实现方式，可以看出来如果用线程来实现，那么就需要用锁来保护共享资源，但是协程就是函数执行过程中，通过yield来暂停等待其他函数的输入，通过send函数跑到yield处执行。开销要小很多。当然Python也有线程，但是受到GIL(全局解释器锁）的局限，也就是说在线程执行的时候，需要获取GIL锁，因此退化为单线程了，也就是说可以在多个线程中切换，但是不能多个线程同时执行，这样的话只能并发不能并行，对于多核CPU来说无疑是一种浪费。

Python 协程的实现

mark 晚点再补 https://zhuanlan.zhihu.com/p/45168167
1、yield/send

2、select

3、yield from
yield from iterable本质上等于for item in iterable: yield item的缩写版

4、asyncio

5、async/await

二、gevent的使用方式

gevent是用的比较多的Python框架，以协程为核心，结合epoll的多路复用，解决了GIL锁的问题？？比起原生的Python来说是封装的更好？还是存在的优化比较多？可以让python代码很方便的使用线程?这块不是很理解。
spawn方法注册方法到gevent实例上，joinall函数循环事件，当遇到IO的时候，会自动切换其他事件。

from gevent import monkey; monkey.patch_all()
import gevent
import requests
from datetime import datetime


def f(url):
    print 'time: %s, GET: %s' % (datetime.now(), url)
    resp = requests.get(url)
    print 'time: %s, %d bytes received from %s.' % (
        datetime.now(), len(resp.text), url)


gevent.joinall([
        gevent.spawn(f, 'https://www.python.org/'),
        gevent.spawn(f, 'https://www.yahoo.com/'),
        gevent.spawn(f, 'https://github.com/'),
])

image.png

此外，加锁也是十分方便的。

# -*- coding: utf-8 -*-

import gevent
from gevent.lock import Semaphore

sem = Semaphore(1)


def f1():
    for i in range(5):
        sem.acquire()
        print 'run f1, this is ', i
        sem.release()
        gevent.sleep(1)


def f2():
    for i in range(5):
        sem.acquire()
        print 'run f2, that is ', i
        sem.release()
        gevent.sleep(0.3)


t1 = gevent.spawn(f1)
t2 = gevent.spawn(f2)
gevent.joinall([t1, t2])

三、greenlet的内部原理

greenlet是gevent的基础，用来实现从协程到协程之间的切换。切换使用的方法是switch。

from greenlet import greenlet
def test1():
    print 12
    gr2.switch()
    print 34

def test2():
    print 56
    gr1.switch()
    print 78

gr1 = greenlet(test1)
gr2 = greenlet(test2)
gr1.switch()

用ppt画了个很丑陋的图，为了是将代码的执行过程描述清楚，greenlet初始化的时候初始化一个空栈，当执行gr1.switch时候，会执行test1的代码，打印12，然后当前协程挂起，保存当前栈和寄存器。之后执行gr2.switch切换到另一个栈，执行print56，然后gr1.switch的时候又切回gr1栈，恢复栈和寄存器，执行print34。

image.png

输出结果如下所示：

image.png
从这个例子来看栈的执行似乎，switch跟函数调用很相似。但是switch not call。每个greenlet都有一个parent，greenlet的创生环境就是它的Parent，所有的greenlet形成一棵树。从下面的例子可以看出来。从test2返回后回到的是main，而不是test1，从这也能看出来他们的区别。

import greenlet
def test1(x, y):
    print id(greenlet.getcurrent()), id(greenlet.getcurrent().parent) # 40240272 40239952
    z = gr2.switch(x+y)
    print 'back z', z

def test2(u):
    print id(greenlet.getcurrent()), id(greenlet.getcurrent().parent) # 40240352 40239952
    return 'hehe'

gr1 = greenlet.greenlet(test1)
gr2 = greenlet.greenlet(test2)
print id(greenlet.getcurrent()), id(gr1), id(gr2)     # 40239952, 40240272, 40240352
print gr1.switch("hello", " world"), 'back to main'    # hehe back to main

四、gevent源码分析

源码这块功底不够，确实有些看不懂了，先mark一下
https://www.jianshu.com/p/f55148c41f54