用greenlet实现Python中的并发

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()

这里创建了两个greenlet协程对象,gr1和gr2,分别对应于函数test1()和test2()。使用greenlet对象的switch()方法,即可以切换协程。上例中,我们先调用”gr1.switch()”,函数test1()被执行,然后打印出”12″;接着由于”gr2.switch()”被调用,协程切换到函数test2(),打印出”56″;之后”gr1.switch()”又被调用,所以又切换到函数test1()。但注意,由于之前test1()已经执行到第5行,也就是”gr2.switch()”,所以切换回来后会继续往下执行,也就是打印”34″;现在函数test1()退出,同时程序退出。由于再没有”gr2.switch()”来切换至函数test2(),所以程序第11行”print 78″不会被执行。

12
56
34

父子关系

创建协程对象的方法其实有两个参数”greenlet(run=None, parent=None)”。参数”run”就是其要调用的方法,比如上例中的函数test1()和test2();参数”parent”定义了该协程对象的父协程,也就是说,greenlet协程之间是可以有父子关系的。如果不设或设为空,则其父协程就是程序默认的”main”主协程。这个”main”协程不需要用户创建,它所对应的方法就是主程序,而所有用户创建的协程都是其子孙。大家可以把greenlet协程集看作一颗树,树的根节点就是”main”,上例中的”gr1″和”gr2″就是其两个字节点。

在子协程执行完毕后,会自动返回父协程。比如上例中test1()函数退出,代码会返回到主程序。让我们写个更清晰的例子来实验下:

from greenlet import greenlet

def test1():
    print 12
    gr2.switch()
    print 34

def test2():
    print 56

gr1 = greenlet(test1)
gr2 = greenlet(test2, gr1)
gr1.switch()
print 78

这里创建greenlet对象”gr2″时,指定了其父协程是”gr1″。所以在函数test2()里,虽然没有”gr1.switch()”代码,但是在其退出后,程序一样回到了函数test1(),并且执行”print 34″。同样,在test1()退出后,代码回到了主程序,并执行”print 78″。所以,最后的输出就是:

12
56
34
78

如果上例中,”gr2″的父协程不是”gr1″而是”main”的话,那test2()运行完毕就会回到主程序并直接打印”78″,这样”print 34″就不会执行。大家可以试一试。

还有一个重要的点,就是协程退出后,就无法再被执行了。如果上例在函数test1()中,再加一句”gr2.switch()”,运行的结果是一样的。因为第二次调用”gr2.switch()”,什么也不会运行。

def test1():
    print 12
    gr2.switch()
    print 34
    gr2.switch()

大家可能会感觉到父子协程之间的关系,就像函数调用一样,一个嵌套一个。的确,其实greenlet协程的实现就是使用了栈,其运行的上下文保存在栈中,”main”主协程处于栈底的位置,而当前运行中的协程就在栈顶。这同函数是一样。此外,在任何时候,你都可以使用”greenlet.getcurrent()”,获取当前运行中的协程对象。比如在函数test2()中执行”greenlet.getcurrent()”,其返回就等于”gr2″。

异常

既然协程是存放在栈中,那一个协程要抛出异常,就会先抛到其父协程中,如果所有父协程都不捕获此异常,程序才会退出。我们试下,把上面的例子中函数test2()的代码改为:

def test2():
    print 56
    raise NameError

程序执行后,我们可以看到Traceback信息:

  File "parent.py", line 14, in
    gr1.switch()
  File "parent.py", line 5, in test1
    gr2.switch()
  File "parent.py", line 10, in test2
    raise NameError

如果将”gr2″的父协程设为空,Traceback信息就会变为:

 File "parent.py", line 14, in
    gr1.switch()
  File "parent.py", line 10, in test2
    raise NameError

因此,如果”gr2″的父协程是”gr1″的话,异常先回抛到函数test1()的代码”gr2.switch()”处。所以,我们再对函数test1()改动下:

def test1():
    print 12
    try:
        gr2.switch()
    except NameError:
        print 90
    print 34

运行后的结果,如果”gr2″的父协程是”gr1″,则异常被捕获,并打印90。否则,异常会被抛出。以上实验很好的证明了,子协程抛出的异常会根据栈里的顺序,依次抛到父协程里。

有一个异常是特例,不会被抛到父协程中,那就是”greenlet.GreenletExit”,这个异常会让当前协程强制退出。比如,我们将函数test2()改为:

def test2():
    print 56
    raise greenlet.GreenletExit
    print 78

那代码行”print 78″永远不会被执行。但这个异常不会往上抛,所以其父协程还是可以正常运行

另外,我们可以通过greenlet对象的”throw()”方法,手动往一个协程里抛个异常。比如,我们在test1()里调一个throw()方法:

def test1():
    print 12
    gr2.throw(NameError)
    try:
        gr2.switch()
    except NameError:
        print 90
    print 34

这样,异常就会被抛出,运行后的Trackback是这样的:

  File "exception.py", line 21, in
    gr1.switch()
  File "exception.py", line 5, in test1
    gr2.throw(NameError)

如果将”gr2.throw(NameError)”放在”try”语句中,那该异常就会被捕获,并打印”90″。另外,当”gr2″的父协程不是”gr1″而是”main”时,异常会直接抛到主程序中,此时函数test1()中的”try”语句就不起作用了。

协程间传递消息

在介绍生成器时,我们聊过可以使用生成器的send()方法来传递参数。greenlet也同样支持,只要在其switch()方法调用时,传入参数即可。我们再来基于本文第一个例子改造下:

from greenlet import greenlet

def test1():
    print 12
    y = gr2.switch(56)
    print y

def test2(x):
    print x
    gr1.switch(34)
    print 78

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

在test1()中调用”gr2.switch()”,由于协程”gr2″之前未被启动,所以传入的参数”56″会被赋在test2()函数的参数”x”上;在test2()中调用”gr1.switch()”,由于协程”gr1″之前已执行到第5行”y = gr2.switch(56)”这里,所以传入的参数”34″会作为”gr2.switch(56)”的返回值,赋给变量”y”。这样,两个协程之间的互传消息就实现了。

生产者消费者的例子,改为greenlet实现吧:

from greenlet import greenlet

def consumer():
    last = ‘‘
    while True:
        receival = pro.switch(last)
        if receival is not None:
            print ‘Consume %s‘ % receival
            last = receival

def producer(n):
    con.switch()
    x = 0
    while x < n:
        x += 1
        print ‘Produce %s‘ % x
        last = con.switch(x)

pro = greenlet(producer)
con = greenlet(consumer)
pro.switch(5)
时间: 2024-10-18 03:40:38

用greenlet实现Python中的并发的相关文章

Python中的并发编程

简介 我们将一个正在运行的程序称为进程.每个进程都有它自己的系统状态,包含内存状态.打开文件列表.追踪指令执行情况的程序指针以及一个保存局部变量的调用栈.通常情况下,一个进程依照一个单序列控制流顺序执行,这个控制流被称为该进程的主线程.在任何给定的时刻,一个程序只做一件事情. 一个程序可以通过Python库函数中的os或subprocess模块创建新进程(例如os.fork()或是subprocess.Popen()).然而,这些被称为子进程的进程却是独立运行的,它们有各自独立的系统状态以及主线

Python中并发、多线程等

1.基本概念 并发和并行的区别: 1)并行,parallel 同时做某些事,可以互不干扰的同一时刻做几件事.(解决并发的一种方法) 高速公路多个车道,车辆都在跑.同一时刻. 2)并发 concurrency 同时做某些事,一个时段内有事情要处理.(遇到的问题) 高并发,同一时刻内,有很多事情要处理. 2.并发的解决 1)队列.缓冲区 排队就是把人排成队列,先进先出,解决了资源使用的问题. 排成的队列,其实就是一个缓冲地带,就是缓冲区. Queue模块的类queue.lifoqueue.prior

python中并发编程基础1

并发编程基础概念 1.进程. 什么是进程? 正在运行的程序就是进程.程序只是代码. 什么是多道? 多道技术: 1.空间上的复用(内存).将内存分为几个部分,每个部分放入一个程序,这样同一时间在内存中就有了多道程序. 2.时间上的复用(CPU的分配).只有一个CPU,如果程序在运行过程中遇到了I/O阻塞或者运行时间足够长.操作系统会按照算法将CPU分配给其他程序使用,依次类推.直到第一个程序被重新分配到CPU会继续运行. 多道技术中的问题解决: 空间复用:程序之间的内存必须分割.这种分割需要在硬件

Python 中的进程、线程、协程、同步、异步、回调

进程和线程究竟是什么东西?传统网络服务模型是如何工作的?协程和线程的关系和区别有哪些?IO过程在什么时间发生? 在刚刚结束的 PyCon2014 上海站,来自七牛云存储的 Python 高级工程师许智翔带来了关于 Python 的分享<Python中的进程.线程.协程.同步.异步.回调>. 一.上下文切换技术 简述 在进一步之前,让我们先回顾一下各种上下文切换技术. 不过首先说明一点术语.当我们说"上下文"的时候,指的是程序在执行中的一个状态.通常我们会用调用栈来表示这个状

python中的进程、线程(threading、multiprocessing、Queue、subprocess)

Python中的进程与线程 学习知识,我们不但要知其然,还是知其所以然.你做到了你就比别人NB. 我们先了解一下什么是进程和线程. 进程与线程的历史 我们都知道计算机是由硬件和软件组成的.硬件中的CPU是计算机的核心,它承担计算机的所有任务. 操作系统是运行在硬件之上的软件,是计算机的管理者,它负责资源的管理和分配.任务的调度. 程序是运行在系统上的具有某种功能的软件,比如说浏览器,音乐播放器等. 每次执行程序的时候,都会完成一定的功能,比如说浏览器帮我们打开网页,为了保证其独立性,就需要一个专

python中的线程(zz)

引言 一.线程 1.1 普通的多线程1.2 自定义线程类1.3 线程锁1.3.1 未使用锁1.3.2 普通锁Lock和RLock1.3.3 信号量(Semaphore)1.3.4 事件(Event)1.3.5 条件(condition)1.3 全局解释器锁(GIL)1.4 定时器(Timer)1.5 队列1.5.1 Queue:先进先出队列1.5.2 LifoQueue:后进先出队列1.5.3 PriorityQueue:优先级队列1.5.4 deque:双向队列1.6 生产者消费者模型1.7

python中协程

协程是python中除了进程和线程之外又一种能够实现多任务的方式,又称为微线程,纤程,它相比于线程需要的资源更少. 在python种协程是通过generator实现的.通过yield保存当前运行的状态然后切换到另一个协程执行.普通的生产者-消费这模式是一个线程写消息,一个线程才能读取消息,因此需要控制队列的写入与读取数据.而改用协程可以在生产者生产消息后直接通过yield跳转到消费者开始执行,执行完毕后在切换到生产者,如此反复,效率极高. 在图中,我们可以看出通过next的方法使得生成器中的任务

Python 开源异步并发框架的未来(转)

Python 开源异步并发框架的未来 fantix 1.1k 2014年04月16日 发布 推荐 4 推荐 收藏 31 收藏,8.9k 浏览 呵呵,这个标题有点大,其实只是想从零开始介绍一下异步的基础,以及 Python 开源异步并发框架的发展和互操作性. 另外,这是我在 OSTC 2014 做的一个 20140330-OSTC-分论坛1王川 http://v.youku.com/v_show/id_XNjk2ODI0ODQ4.html ,幻灯片在这里,欢迎拍砖. 开源 Python 是开源的,

python中yield使用

16.yield使用 列表推导与生成器表达式 当我们创建了一个列表的时候,就创建了一个可以迭代的对象: >>> squares=[n*n for n in range(3)] >>> for i in squares:     print i 0 1 4 这种创建列表的操作很常见,称为列表推导.但是像列表这样的迭代器,比如str.file等,虽然用起来很方便,但有一点,它们是储存在内存中的,如果值很大,会很麻烦. 而生成器表达式不同,它执行的计算与列表包含相同,但会迭代