gevent模块学习(一)

1.Event类,事件主要用于Greenlet之间的异步通信

e = gevent.event.Event() -> Event

说明: 创建一个信号对象

e.set() -> None

说明: 设置标志位

e.clear() -> None

说明: 清除标志位

e.wait() -> None

说明: 阻塞直至标志位被设置

 

扩展：

a = gevent.event.AsyncResult() -> AsyncResult

说明: 创建一个扩展可携带数据的信号对象

a.set(value=None) -> None

说明: 设置带数据的标志位

a.e.clear() -> None

说明: 清除带数据的标志位

a.get(block=True, timeout=None) -> obj

说明: 阻塞直至标志位被设置并返回value值,可设置timeout到点抛出Timeout异常

#coding:utf-8

# 1 事件 event
# 是一个在Greenlet之间异步通信的形式
import gevent
from gevent.event import Event

evt = Event()

# evt.set() 设置flag
# evt.clear() 清除
# evt.wait()  阻塞等待

def setter():
    print('wait for ')
    evt.rawlink(event_callback)  # 注册一个回调
    gevent.sleep(3)
    print('ok done')
    evt.set()


def waiter():
    print('will wait for u')
    evt.wait()
    print('about time')


def event_callback(evt):
    print('callback')


def main():
    gevent.joinall([
        gevent.spawn(setter),
        gevent.spawn(waiter),
        gevent.spawn(waiter),
        gevent.spawn(waiter),
        gevent.spawn(waiter),
        gevent.spawn(waiter),
    ])


if __name__ == "__main__":
    main()

# coding:utf-8

import gevent

import time
from gevent import event  # 调用gevent的event子模块


# 三个进程需要定义三个事件event1,event2,event3，来进行12,23,31循环机制，即进程一，进程二，进程三顺序执行

def fun1(num, event1, event2):  # 固定格式

    i = 0

    while i < 10:  # 设置循环10次

        i += 1

        time.sleep(1)  # 睡眠1秒

        print'进程一：111111111'

        event2.set()  # 将event2值设为True

        event1.clear()  # 将event1值设为False

        event1.wait()  # event1等待，其值为True时才执行


def fun2(num, event2, event3):
    i = 0

    while i < 10:
        i += 1

        time.sleep(1)

        print'进程二：222222222'

        event3.set()  # 将event3值设为True

        event2.clear()  # 将event2值设为False

        event2.wait()  # event2等待，其值为True时才执行


def fun3(num, event3, event1):
    i = 0

    while i < 10:
        i += 1

        time.sleep(1)

        print'进程三：333333333'

        event1.set()  # 将event1的值设为True

        event3.clear()  # 将event3的值设为False

        event3.wait() # event3 等待，值为True时才执行


if __name__ == "__main__":  # 执行调用格式

    act1 = gevent.event.Event()  # 调用event中的Event类,用act1表示

    act2 = gevent.event.Event()

    act3 = gevent.event.Event()

    # 三个进程，act1,act2,act3

    Gevents = []  # 建立一个数列，用来存和管理进程

    g = gevent.Greenlet(fun1, 1, act1, act2)  # 调用gevent中的Greenlet子模块，用Greenlet创建进程一

    g.start()

    print'进程一启动：'

    Gevents.append(g)  # 将进程一加入到Gevents数列
    g = gevent.Greenlet(fun2, 2, act2, act3)

    g.start()

    print'进程二启动：'

    Gevents.append(g)
    g = gevent.Greenlet(fun3, 3, act3, act1)

    g.start()

    print'进程三启动：'

    print'所有进程都已启动！'

    Gevents.append(g)
    gevent.joinall(Gevents)  # 调用Greenlet中的joinall函数，将Gevents的进程收集排列

# coding:utf-8
# AsyncResult 允许你在唤醒调用上附加一个值，有时也被称作future或defered 因为它持有一个指向将来任意时间可设置为任何值的引用

import gevent
from gevent.event import AsyncResult
a = AsyncResult()

# a.set(value=None)
# a.clear()
# a.get(block=True, timeout=None) 阻塞直至标志位被设置并返回value值， 可设置timeout

def setter():
    gevent.sleep(2)
    a.set('aaaa')


def waiter():
    print(a.get(timeout=5))

gevent.joinall([
    gevent.spawn(setter),
    gevent.spawn(waiter)
 ])