python greenlet背景介绍与实现机制

并发处理的技术背景

并行化处理目前很受重视， 因为在很多时候，并行计算能大大的提高系统吞吐量，尤其在现在多核多处理器的时代， 所以像lisp这种古老的语言又被人们重新拿了起来， 函数式编程也越来越流行。 介绍一个python的并行处理的一个库： greenlet。 python 有一个非常有名的库叫做 stackless ，用来做并发处理， 主要是弄了个叫做tasklet的微线程的东西， 而greenlet 跟stackless的最大区别是， 他很轻量级？不够， 最大的区别是greenlet需要你自己来处理线程切换， 就是说，你需要自己指定现在执行哪个greenlet再执行哪个greenlet。

greenlet的实现机制

以前使用python开发web程序,一直使用的是fastcgi模式.然后每个进程中启动多个线程来进行请求处理.这里有一个问题就是需要保证每个请求响应时间都要特别短,不然只要多请求几次慢的就会让服务器拒绝服务,因为没有线程能够响应请求了.平时我们的服务上线都会进行性能测试的,所以正常情况没有太大问题.但是不可能所有场景都测试到.一旦出现就会让用户等好久没有响应.部分不可用导致全部不可用.后来转换到了coroutine,python 下的greenlet.所以对它的实现机制做了一个简单的了解.
每个greenlet都只是heap中的一个python object(PyGreenlet).所以对于一个进程你创建百万甚至千万个greenlet都没有问题.


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

typedef struct _greenlet {

    PyObject_HEAD

    char* stack_start;

    char* stack_stop;

    char* stack_copy;

    intptr_t stack_saved;

    struct _greenlet* stack_prev;

    struct _greenlet* parent;

    PyObject* run_info;

    struct _frame* top_frame;

    int recursion_depth;

    PyObject* weakreflist;

    PyObject* exc_type;

    PyObject* exc_value;

    PyObject* exc_traceback;

    PyObject* dict;

} PyGreenlet;

每一个greenlet其实就是一个函数,以及保存这个函数执行时的上下文.对于函数来说上下文也就是其stack..同一个进程的所有的greenlets共用一个共同的操作系统分配的用户栈.所以同一时刻只能有栈数据不冲突的greenlet使用这个全局的栈.greenlet是通过stack_stop,stack_start来保存其stack的栈底和栈顶的,如果出现将要执行的greenlet的stack_stop和目前栈中的greenlet重叠的情况,就要把这些重叠的greenlet的栈中数据临时保存到heap中.保存的位置通过stack_copy和stack_saved来记录,以便恢复的时候从heap中拷贝回栈中stack_stop和stack_start的位置.不然就会出现其栈数据会被破坏的情况.所以应用程序创建的这些greenlet就是通过不断的拷贝数据到heap中或者从heap中拷贝到栈中来实现并发的.对于io型的应用程序使用coroutine真的非常舒服.

下面是greenlet的一个简单的栈空间模型(from greenlet.c)


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

A PyGreenlet is a range of C stack addresses that must be

saved and restored in such a way that the full range of the

stack contains valid data when we switch to it.

Stack layout for a greenlet:

               |     ^^^       |

               |  older data   |

               |               |

  stack_stop . |_______________|

        .      |               |

        .      | greenlet data |

        .      |   in stack    |

        .    * |_______________| . .  _____________  stack_copy + stack_saved

        .      |               |     |             |

        .      |     data      |     |greenlet data|

        .      |   unrelated   |     |    saved    |

        .      |      to       |     |   in heap   |

 stack_start . |     this      | . . |_____________| stack_copy

               |   greenlet    |

               |               |

               |  newer data   |

               |     vvv       |

下面是一段简单的greenlet代码:

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

目前所讨论的协程，一般是编程语言提供支持的。目前我所知提供协程支持的语言包括python，lua，go，erlang, scala和rust。协程不同于线程的地方在于协程不是操作系统进行切换，而是由程序员编码进行切换的，也就是说切换是由程序员控制的，这样就没有了线程所谓的安全问题。
所有的协程都共享整个进程的上下文，这样协程间的交换也非常方便。
相对于第二种方案（I/O多路复用），使得使用协程写的程序将更加的直观，而不是将一个完整的流程拆分成多个管理的事件处理。
协程的缺点可能是无法利用多核优势，不过，这个可以通过协程+进程的方式来解决。
协程可以用来处理并发来提高性能，也可以用来实现状态机来简化编程。我用的更多的是第二个。去年年底接触python，了解到了python的协程概念，后来通过pycon china2011接触到处理yield，greenlet也是一个协程方案，而且在我看来是更可用的一个方案，特别是用来处理状态机。
目前这一块已经基本完成，后面抽时间总结一下。

总结一下：
1）多进程能够利用多核优势，但是进程间通信比较麻烦，另外，进程数目的增加会使性能下降，进程切换的成本较高。程序流程复杂度相对I/O多路复用要低。
2）I/O多路复用是在一个进程内部处理多个逻辑流程，不用进行进程切换，性能较高，另外流程间共享信息简单。但是无法利用多核优势，另外，程序流程被事件处理切割成一个个小块，程序比较复杂，难于理解。
3）线程运行在一个进程内部，由操作系统调度，切换成本较低，另外，他们共享进程的虚拟地址空间，线程间共享信息简单。但是线程安全问题导致线程学习曲线陡峭，而且易出错。
4）协程有编程语言提供，由程序员控制进行切换，所以没有线程安全问题，可以用来处理状态机，并发请求等。但是无法利用多核优势。
上面的四种方案可以配合使用，我比较看好的是进程+协程的模式

时间： 2024-10-13 05:38:53

python greenlet背景介绍与实现机制的相关文章

《python源码剖析》笔记 python虚拟机中的函数机制

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie 1.Python虚拟机在执行函数调用时会动态地创建新的 PyFrameObject对象, 这些PyFrameObject对象之间会形成PyFrameObject对象链,模拟x86平台上运行时栈 2.PyFuctionObject对象 typedef struct { PyObject_HEAD PyObject *func_code: //对应函数编译后的PyCodeObject对象 Py

python中的*和**参数传递机制

python的参数传递机制具有值传递(int.float等值数据类型)和引用传递(以字典.列表等非值对象数据类型为代表)两种基本机制以及方便的关键字传递特性(直接使用函数的形参名指定实参的传递目标,如函数定义为def f(a,b,c),那么在调用时可以采用f(b=1,c=2,a=3)的指定形参目标的传递方式,而不必拘泥于c语言之类的形参和实参按位置对应) 除此之外,python中还允许包裹方式的参数传递,这未不确定参数个数和参数类型的函数调用提供了基础: def f(*a,**b) 包裹参数传递

python变量存储的缓存机制

python变量存储的缓存机制 1.  在同一文件(模块)里 1.对于整型而言,-5~正无穷范围内的相同值 id一致 2.对于浮点数而言,非负数范围内的相同值 id一致 3.布尔值而言,值相同情况下,id一致 4.复数的id标识都不相同(在 实数+虚数 这样的结构中) 5.字符串而言,字符串值相同情况下,id一致 6.列表,元组,字典,集合无论什么情况 id标识都不同(但空元组的id标识一样) 2.  不同文件(模块)里,部分数据驻留小数据池中 python提前在内存中创建了-5~256 范围的

（编程语言+python+变量名+垃圾回收机制）*知识点

编程语言 从低级到高级的发展的过程 1.机器语言 计算机是基于电工作的.(基于高.低电平 1010010101011) 如果用机器语言表现一个字符的意思需要多段代码的行.但是计算机读取的快. 所以机器语言的 优点:执行速度够快 缺点:开发效率非常低 2.汇编语言 汇编语言的属性,汇编语言通过英文字符组成 优点:执行效率相较于机器语言略低 缺点:开发效率相较于机器语言略高 举个例子: ; hello.asm section .data ; 数据段声明 msg db "Hello, world!&q

Python 代码块、缓存机制

Python 代码块.缓存机制 相同的字符串在Python中地址相同 s1 = 'panda' s2 = 'panda' print(s1 == s2) #True print(id(s1) == id (s2)) #True 2.代码块: ? 所有的代码都需要依赖代码块执行. ? 一个模块,一个函数,一个类,一个文件等都是一个代码块 ? 交互式命令中, 一行就是一个代码块 3.缓存机制: ? 同一代码块下的缓存机制 ? 适用对象:int(float),bool,str ? 具体细则:所有的数字

Python模块动态加载机制

本文和大家分享的主要是python中模块动态加载机制相关内容,一起来看看吧,希望对大家学习python有所帮助. import 指令 来看看 import sys 所产生的指令: co_consts : (0, None) co_names : ('sys',) 0 LOAD_CONST               0 (0) 2 LOAD_CONST               1 (None) 4 IMPORT_NAME              0 (sys) 6 STORE_NAME  

Python中的垃圾回收机制

当我们声明一个对象的时候,例如str="abcdef",当我们不再使用str这个对象的时候,这个对象就是一个脏对象,垃圾对象,但是它还在占着内存,毕竟我们的电脑内存有限,所以应该有一个机制来回收它以及类似的对象.现在的高级语言如java,c#等,都采用了垃圾收集机制,而不再是c,c++里用户自己管理维护内存的方式.自己管理内存极其自由,可以任意申请内存,但如同一把双刃剑,为大量内存泄露,悬空指针等bug埋下隐患. 对于一个字符串.列表.类甚至数值都是对象,且定位简单易用的语言,自然不会

Python学习心得(六) 反射机制、装饰器

1.反射机制 #/usr/bin/env python # -*- coding:utf-8 -*- ''' Python反射机制的核心本质:利用字符串的形式去对象(模块)中操作(查找/获取/删除/添加)成员,一种基于字符串的事件驱动 通俗讲就是通过用户传入url的不同,调用不同的模块函数,好多比较流行的web框架都是通过反射的机制,根据url的不同指向不同的模块 getattr(),hasattr(),setattr(),delattr()对模块的修改都在内存中进行,并不会影响文件中的真实内容

Python之异常抛出机制

异常抛出机制 : 常见的Python异常: