python async模块使用

# 一个简单的事件循环
import asyncio

loop = asyncio.get_event_loop()

# 注册并执行循环

import functools

def hello():
    print('hello world!')

def stop_loop(loop):

    print('stop loop')
    loop.stop()

# 注册函数
# loop.call_soon(hello)
# loop.call_soon(functools.partial(stop_loop,loop))
# loop.run_forever()

# 延迟调用

# loop.call_later(10,hello)
# loop.call_later(12,functools.partial(stop_loop,loop))
# loop.run_forever()

# 任务结束前执行循环
@asyncio.coroutine #将一个函数转变为一个协程
def trivial():
    print('hello world')

loop.run_until_complete(trivial())

# 执行一个后台循环
import threading

def run_loop_forever_in_background(loop):
    def thread_func(l):
        asyncio.set_event_loop(l)
        l.run_forever()

    thread = threading.Thread(target=thread_func,args=(loop,))
    thread.start()
    return thread

loop = asyncio.get_event_loop()
# run_loop_forever_in_background(loop)
# print(loop.is_running()) #循环通知非常困难

# 协程
@asyncio.coroutine
def coro_sum(*args):
    answer = 0
    for i in args:
        answer += i
    return answer

loop = asyncio.get_event_loop()

result = loop.run_until_complete(coro_sum(2,3,4,5))
print(result)

# 嵌套的协程########################################################

import asyncio

@asyncio.coroutine
def nested(args):

    print('the nested function ran with args %r' %(args,))

    return [i+1 for i in args]

@asyncio.coroutine
def outer(*args):
    print('the outer function ran with args %r'%(args,))
    answer = yield from nested([i*2 for i in args])
    return answer

loop = asyncio.get_event_loop()
re = loop.run_until_complete(outer(2,3,5,8))
print(re)

"""
future对象:是一个独立的对象,并不依赖正在执行的函数,该对象仅仅用于存储状态和结果信息,此外别无他用
Task对象是future的子类,每当一个协程事件被安排执行后,协程就会被一个task对象包装,task对象的任务是存储结果
并为yield from 语句提供值
"""
@asyncio.coroutine
def make_tea(variety):
    print('now making %s tea.' %variety)

    asyncio.get_event_loop().stop()
    return '%s tea' %variety



# 将事件注册到循环中
# task = asyncio.async(make_tea('chamoile'))
#
# loop = asyncio.get_event_loop()

# loop.run_forever()
# print(task.result())

# 回调##################################################
loop = asyncio.get_event_loop()

@asyncio.coroutine
def make_tea_v1(variety):
    print('now making %s tea.' %variety)

    return '%s tea' %variety


def confirm_tea(future):
    print('the %s is made'%future.result())

task = asyncio.async(make_tea_v1('chamoile'))

task.add_done_callback(confirm_tea)

loop.run_until_complete(task)

# 带参数的回调###################################################

def add_ingredient(ingredient,future):
    print('now add %s to %s' %(ingredient,future.result()))


# 使用偏置函数添加参数,其他不变
task.add_done_callback(functools.partial(add_ingredient,'honey'))


# 任务聚合#########################################################

import asyncio

loop = asyncio.get_event_loop()

@asyncio.coroutine
def make_tea_v1(variety):
    print('now making %s tea.' %variety)
    return '%s tea' %variety


meta_task = asyncio.gather(make_tea_v1('chamomile'),
               make_tea_v1('green'))

loop.run_until_complete(meta_task)
print(meta_task.result()) #返回的总是列表 ['chamomile tea', 'green tea']

# 等待任务#####################################
#传输为一个列表
meta_task = asyncio.wait([make_tea_v1('chamomile'),
               make_tea_v1('green')])

#超时

meta_task1 = asyncio.wait([make_tea_v1('chamomile'),
               make_tea_v1('green')],timeout=3)

loop.run_until_complete(meta_task1)


#等待任意任务

meta_task2 = asyncio.wait([make_tea_v1('chamomile'),
               make_tea_v1('green')],return_when=asyncio.FIRST_COMPLETED)

# print(meta_task2.result())
loop.run_until_complete(meta_task2)

#等待异常
meta_task3 = asyncio.wait([asyncio.sleep(1),asyncio.sleep(2)],return_when=asyncio.FIRST_EXCEPTION)


#服务器

class Shutdown(asyncio.Protocol):

    pass

class ServerProtocol(asyncio.Protocol):

    def connection_made(self,transport):
        self.transport = transport
        self.write('welcome')

    def data_received(self, data):
        if not data:
            return

        message = data.decode('ascii')
        command = message.strip().split(' ')[0].lower()
        args = message.strip().split(' ')[1:]

        if not hasattr(self,'command_%s' %command):
            self.write('Invalid command %s' %command)
        try:
            return getattr(self,'command_%s' %command)(*args)
        except Exception as e:
            self.write('Error %s' %str(e))

    def write(self,mesg_string):
        # mesg_string += '\n'
        self.transport.write(mesg_string.encode('ascii','ignore'))

    def command_add(self,*args):
        args = [int(i) for i in args]
        self.write('%d'%sum(args))

    def command_shutdown(self):
        self.write('Okay,shutdown')
        raise KeyboardInterrupt

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    core = loop.create_server(ServerProtocol,'127.0.0.1',8000)
    asyncio.async(core)

    try:
        loop.run_forever()
    except KeyboardInterrupt:
        pass