def spawn_raw(function, *args, **kwargs):
hub = get_hub()
if kwargs:
g = greenlet(_switch_helper, hub)
hub.loop.run_callback(g.switch, function, args, kwargs)
else:
g = greenlet(function, hub)
hub.loop.run_callback(g.switch, *args)
return g
def test_greenlet_tracing():
def callback(event, args):
print event, 'from', id(args[0]), 'to', id(args[1])
def dummy():
g2.switch()
def dummyexception():
raise Exception('except in coroutine')
main = greenlet.getcurrent()
g1 = greenlet(dummy)
g2 = greenlet(dummyexception)
print 'main id %s, gr1 id %s, gr2 is %s' % (id(main), id(g1), (g2))
oldtrace = greenlet.settrace(callback)
try:
g1.switch()
except:
print 'Exception'
finally:
greenlet.settrace(oldtrace)
def show_leak():
def test11():
gr12.switch()
# def test12():
# huge.extend([x*x for x in range(100)])
# gr11.switch()
# print 'finish switch del huge'
# del huge[:]
def test12():
huge.extend([x * x for x in range(100)])
try:
gr11.switch()
finally:
print 'finish switch del huge'
del huge[:]
gr11 = greenlet(test11)
gr12 = greenlet(test12)
gr11.switch()
gr11 = gr12 = None
print 'length of huge is zero ? %s' % len(huge)
def __new__(cls, func):
if greenlet is None:
raise RuntimeError('IterI requires greenlet support')
stream = object.__new__(cls)
stream.__init__(greenlet.getcurrent())
def run():
func(stream)
stream.flush()
g = greenlet(run, stream._parent)
while 1:
rv = g.switch()
if not rv:
return
yield rv[0]
def __new__(cls, func):
if greenlet is None:
raise RuntimeError('IterI requires greenlet support')
stream = object.__new__(cls)
stream.__init__(greenlet.getcurrent())
def run():
func(stream)
stream.flush()
g = greenlet(run, stream._parent)
while 1:
rv = g.switch()
if not rv:
return
yield rv[0]
import greenlet
def test1(n):
print "test1:", n
gr2.switch(32)
print "test1: over"
def test2(n):
print "test2:", n
gr1.switch(23)
print "test2: over"
greenlet = greenlet.greenlet
current = greenlet.getcurrent()
gr1 = greenlet(test1, current)
gr2 = greenlet(test2, current)
gr1.switch(2)
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author = "Hero_lws"
import greenlet
# 第三方库
# greelet指的是使用一个任务调度器和一些生成器或者协程实现协作式用户空间多线程的一种伪并发机制，即所谓的微线程。
# greelet机制的主要思想是：
# 生成器函数或者协程函数中的yield语句挂起函数的执行，直到稍后使用next()或send()操作进行恢复为止。可以使用一个调度器循环在一组生成器函数之间协作多个任务。
from greenlet import greenlet
import time
def t1():
print(12) # 2
gr2.switch() # 3
print(34) # 6
gr2.switch() # 7
def t2():
print(56) # 4
gr1.switch() # 5
print(78) # 8
gr1 = greenlet(t1) # 启动一个协程
gr2 = greenlet(t2)
gr1.switch() # 手动切换 1
from greenlet import *
import time
def task1():
while True:
print('------task1------')
grt2.switch()
time.sleep(0.5)
def task2():
while True:
print('------task2------')
grt1.switch()
time.sleep(0.5)
if __name__ == '__main__':
grt1 = greenlet(task1)
grt2 = greenlet(task2)
grt1.switch()
#coding=utf-8
#利用greenlet 框架实现多任务
# http://blog.csdn.net/shuaijiasanshao/article/details/51475571
#greenlet是python的并行处理的一个库。 python 有一个非常有名的库叫做 stackless ，用来做并发处理， 主要是弄了个叫做tasklet的微线程的东西， 而greenlet 跟stackless的最大区别是greenlet需要你自己来处理线程切换， 就是说，你需要自己指定现在执行哪个greenlet再执行哪个greenlet。
from greenlet import *
def test1():
print("1")
gr2.switch()
print("2")
def test2():
print("3")
gr1.switch()
print("4")
gr1 = greenlet(test1)
gr2 = greenlet(test2)
gr1.switch()
print(
"最后一行跳转到 test1() ，它打印1，然后跳转到 test2() ，打印3，然后跳转回 test1() ，打印2，然后 test1() 就结束，gr1 dead。这时执行会回到原来的 gr1.switch()"
)
def main():
gr1 = greenlet(task_1)
gr2 = greenlet(task_2)
# 切换到gr1中运行
gr1.switch()
def spawn_raw(function, *args, **kwargs):
hub = get_hub()
g = greenlet(function, hub)
hub.loop.run_callback(g.switch, *args, **kwargs)
return g
# 测试函数1
from greenlet import *
def f1():
print(12)
# 执行f1
gr2.switch() #切到gs2 且一次如果没有继续切就盘完 gs2 如果切了就跑一句
print(34)
gr2.switch() #切到gs2
# 测试函数2
def f2():
print(56) #切到gs1
gr1.switch()
print(78) #切到gs1
# 创建协程对象
gr1 = greenlet(f1)
gr2 = greenlet(f2)
# 启动协程函数
gr1.switch() # 12 56 34
#greenlet 最大的特点是需要手工切换
def a(i):
while i < 9:
print('唱第%d首歌'.format(i))
i += 1
#g2.switch()
time.sleep(0.2)
def b(j):
while j < 7:
print('跳第%d只舞'.format(j))
j += 1
#g3.switch()
time.sleep(0.2)
def c(k):
while k < 7:
print('跳第%d只舞'.format(k))
k += 1
#g1.switch()
time.sleep(0.2)
if __name__ == '__main__':
g1 = greenlet(a(4))
g2 = greenlet(b(5))
g3 = greenlet(c(3))
# g1.switch()
import greenlet
def func1():
print(1)
gr2.switch()
print(2)
gr2.switch()
def func2():
print(3)
gr1.switch()
print(4)
gr1 = greenlet(func1)
gr2 = greenlet(func2)
gr1.switch() # 去执行func1函数
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()
print dir(greenlet)
# print dir(greenlet.greenlet)
def test3(x, y):
z = gr4.switch(x + y)
print('test3', z)
def test4(u):
print("test4", u)
gr3.switch(10)
def test1():
while True:
print('----test1-----')
t2.switch()
time.sleep(0.5)
def test2():
while True:
print('----test2-----')
t1.switch()
time.sleep(0.5)
t1 = greenlet(test1)
t2 = greenlet(test2)
t1.switch()
# gevent实现协程
def f(n):
for i in range(n):
print(gevent.getcurrent(), i)
gevent.sleep(0.5)
g1 = gevent.spawn(f, 5)
import greenlet
def test1(n):
print "test1:", n
gr2.switch(32)
print "test1: over"
def test2(n):
print "test2:", n
gr1.switch(23)
print "test2: over"
greenlet = greenlet.greenlet
current = greenlet.getcurrent()
gr1 = greenlet(test1, current)
gr2 = greenlet(test2, current)
gr1.switch(2)
import tornado.gen
import greenlet
from greenlet import greenlet
import time
def test1():
print('================1')
x = tornado.gen.sleep(10) # 异步非阻塞的sleep
print(x)
gr2.switch()
print('================3')
def test2():
print('================2')
gr1.switch()
gr1 = greenlet(test1)
gr2 = greenlet(test2)
gr1.switch()
def spawn_raw(function, *args, **kwargs):
hub = get_hub()
g = greenlet(function, hub)
hub.loop.run_callback(g.switch, *args, **kwargs)
return g
fb.switch() # 切换到 fb 中执行
a += 1
print('A........ a = ' + str(a))
fb.switch()
break
def B():
while True:
b = 1
print('B,,,,,,, b = ' + str(b))
fa.switch() # 切换到 fa 中执行
b += 1
print('B........ b = ' + str(b))
break
fa = greenlet(A)
fb = greenlet(B)
# 切换到 fa 执行
fa.switch()
