pyhton协程-gevent

1 线程与协程

1.1 关于线程

• 内核级线程模型 用户线程和KSE 1:1的关系，大部分编程语言的线程库都是对操作系统的KSE的封装，调度工作完全由OS调度器来做，实现方式简单。
• 用户级线程模型 用户线程和KSE M:1的关系，这种线程的创建、销毁以及多个线程之间的协调都是由用户自己的线程库负责的，这也就是协程实现的方式。这种方式下，创建线程的数量和上下文切换所消耗的资源代价会很小。但是有缺点：当我们在某个用户线程发起了阻塞的系统调用（阻塞方式read网络IO），导致线程阻塞这种情况下KSE就会发生阻塞，当内核线程发生阻塞那么cpu将会将当前KSE挂起，对应的用户线程全部变为阻塞状态。 要解决这种问题，常见的就是用户线程里做文章，一旦发生了阻塞的操作，就主动让出当前的用户线程，执行下一个线程，从而避免KSE阻塞。类似python的gevent使用时需要打上一个monkey_patch封装IO操作。
• 混合型线程模型 用户线程和KSE M:N的关系，在一个进程中创建多个KSE，并且线程可以与不同的KSE关联，所以当某一个KSE执行一个阻塞的用户线程的被挂起的时候，与该KSE绑定的其它用户线程将会被分配到其它的KSE，这种动态关联机制时用户实现的，比如go就是实现了该模型，用户调度器实现用户线程到KSE的“调度”，内核调度器实现KSE到CPU上的调度

1.2 协程

2.python协程

2.1 从生成器到协程

def generator():
    for i in range(10):
        yield i
        print 123
a = generator()
next(a)

def generator(g2):
    for i in range(10):
        num = yield 1
a = generator()
a.send(None)
a.send(2)

2.2 greenlet

def test1():
    print("test1 into")
    gr2.switch()
    print("test1 out")
​
​
def test2():
    print("test2 into")
    gr1.switch()
    print("test2 out")
​
​
gr1 = greenlet(test1)
gr2 = greenlet(test2)
gr1.switch()

test1 into
test2 into
test1 out

2.3 gevent

2.3.1 gevent 概念

gevent让操作系统传发出事件让事件循环知道何时一个事件发生了，例如数据已经传输过来了
socket可以读了，从而代替阻塞和一直等待socket操作完成（轮询）的方式。通过这样做，
gevent可以继续运行下一个或许已经有事件就绪的greenlet。这样重复的注册事件以及在事件
发生时进行处理的流程就是事件循环了。

当gevent API中的一个函数A要阻塞的时候，它将获得一个gevent.hub.Hub的实例（Hub实
例是一个非常特别的运行着事件循环的greenlet），然后函数A的那个greenlet被切换到
Hub(将控制权交还给Hub）。如果当时还没有gevent.hub.Hub实例，就会自动创建一个

2.3.2 gevent流程

# _socket3.py
def __init_common(self):
    _socket.socket.setblocking(self._sock, False) # 设置为非阻塞模式的socket
    fileno = _socket.socket.fileno(self._sock) 
    self.hub = get_hub()
    io_class = self.hub.loop.io # 预定义一个 io watcher
    self._read_event = io_class(fileno, 1) # socket的可读事件的 watcher
    self._write_event = io_class(fileno, 2)# socket的可写事件的 watcher
    self.timeout = _socket.getdefaulttimeout()

def get_hub_noargs():
    hub = _threadlocal.hub
    if hub is None:
        hubtype = get_hub_class()
        # 这里的hub是一个线程全局共享变量
        # hubtype在最开始会设置成gevent.hub.Hub
        hub = _threadlocal.hub = hubtype()
    return hub

    def recv(self, *args):
        while True:
            try:
                return self._sock.recv(*args)
            except error as ex:
                # 非阻塞模式下，如果没有数据将会抛出EWOULDBLOCK
                if ex.args[0] != EWOULDBLOCK or self.timeout == 0.0:
                    raise
            # self._read_event是一个io watcher 监听的是读事件
            self._wait(self._read_event)

    def wait(self, watcher):
        waiter = Waiter(self) # pylint:disable=undefined-variable
        watcher.start(waiter.switch, waiter)
        try:
            result = waiter.get()
            if result is not waiter:
                raise xxxx
        finally:
            watcher.stop()

def do_something():
    pass
g1 = gevent.spawn(do_something)
g1.join()

def spawn(cls, *args, **kwargs):
    g = cls(*args, **kwargs)
    g.start()
    return g

_greenlet__init__(self, None, get_hub())
def __init__(self, run=None, parent=None): 
    pass

def start(self):
    """Schedule the greenlet to run in this loop iteration"""
    if self._start_event is None:
        _call_spawn_callbacks(self)
        hub = get_my_hub(self)  # 获取当前的parent协程，也就是hub
        self._start_event = hub.loop.run_callback(self.switch) # 注册到hub的事件循环中

def join():
    result = get_my_hub(self).switch()

If this greenlet has never been run, then this greenlet
will be switched to using the body of self.run(*args, **kwargs).

 def run(self):       
     while 1:
        loop = self.loop
        try:
            loop.run()
        finally:
            loop.error_handler = None  # break the refcount cycle

2.4 asyncio