欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

python3.6以上 asyncio模块的异步编程模型 async await语法

程序员文章站 2022-07-05 15:28:21
运行结果: 参考资料: https://www.cnblogs.com/dhcn/p/9032461.html ......
这是python3.6以上版本的用法,本例是python3.7.2编写
使用asyncio模块的异步编程模型,生产这消费者,异步生产,用sleep来代替io等待
使用async和await语法来进行描述
async关键字描述一个方法是异步函数(协程),是可以被send()的,也是可以被asyncio加入到协程池进行调度的
yield关键字表示在async描述的方法中定义一个出入点,相当于return,但是可以在下一次函数被send()或者循环调用时作为切入点继续向下运行。
await关键字表示挂起等待的io,函数内部后续运算会等待此处io结束再运行,其他协程函数会在此等待时使用cpu进行运行。

#生产这消费者模型,
#消费者到超市购买土豆和西红柿
#需要买50个土豆和50个西红柿
#当前货架上,有5个土豆,5个西红柿
#消费者开始拿取
#具体逻辑
# 一个一个拿东西
#从货架拿土豆,一个一个的,当货架上的土豆拿完了,去问土豆还有没,触发土豆工厂开始做土豆,随机几个,生产需要花费时间,
# 所以,业务上认定为是1秒生产一个,全部生产完成才上架,这里简化为获取时间与生产个数相同,一秒生产一个,这里不是重点,重点是体现了上架需要时间。
#在等待生产上架土豆的过程中,开始拿取西红柿,
#西红柿也是同样道理,等待西红柿时去拿取土豆,如此往复,如果都在未上架,则等待

程序代码如下:
import asyncio,random

class potato:
    '''定义一个土豆生产厂家'''
    @classmethod
    def make(cls, num, *args, **kws):
        potatos = []
        print("开始制造 %s 个土豆" % num)
        for i in range(num):
            print("制造第[%s]土豆"%i)
            potatos.append(cls.__new__(cls, *args, **kws))
        return potatos

# 先生成5个土豆并且上架
all_potatos = potato.make(5)

class tomatos:
    '''定义一个西红柿生产厂家'''
    @classmethod
    def make(cls, num, *args, **kws):
        totatos = []
        print("开始制造 %s 个西红柿" % num)
        for i in range(num):
            print("制造第[%s]西红柿" % i)
            totatos.append(cls.__new__(cls, *args, **kws))

        return totatos

all_tomatos = tomatos.make(5)

async def ask_for_potato():
    '''询问土豆,制造的土豆,上架土豆,忽略写法,直接描述了上架全程所需时间'''
    make_num=random.randint(1, 10)
    print("开始进行挂起,生产%s个土豆"%make_num)
    print("接下来遇到io等待,运行其他协程函数")
    await asyncio.sleep(make_num)
    all_potatos.extend(potato.make(make_num))
    print("已经完成%s个土豆的生产"%make_num)

async def take_potatos(num):
    '''从货架拿取土豆'''
    count = 0
    while true:
        if len(all_potatos) == 0:
            print("开始进行挂起,上架土豆")
            await ask_for_potato()
        potato = all_potatos.pop()
        yield potato
        count += 1
        if count == num:
            break

async def buy_potatos():
    '''购买土豆,放在自己的篮子里,一共拿去50个,描述了一个需求,并开始动作'''
    bucket = []
    async for p in take_potatos(50):
        bucket.append(p)
        print(f'取到土豆: {id(p)}...')

async def ask_for_tomatos():
    '''询问西红柿,制造的西红柿,上架西红柿,忽略写法,直接描述了上架全程所需时间'''
    make_num=random.randint(1, 10)
    print("开始进行挂起,生产%s个西红柿" % make_num)
    print("接下来遇到io等待,运行其他协程函数")
    await asyncio.sleep(make_num)
    all_tomatos.extend(tomatos.make(make_num))
    print("已经完成%s个西红柿的生产"%make_num)

async def take_tomatos(num):
    '''从货架拿取西红柿'''
    count = 0
    while true:
        if len(all_tomatos) == 0:
            print("开始进行挂起,上架西红柿")
            await ask_for_tomatos()
        potato = all_tomatos.pop()
        yield potato
        count += 1
        if count == num:
            break
async def buy_tomatos():
    '''购买西红柿,放在自己的篮子里,一共拿去50个,描述了一个需求,并开始动作'''
    bucket = []
    async for p in take_tomatos(50):
        bucket.append(p)
        print(f'取到西红柿: {id(p)}...')

def main():
    import asyncio
    loop = asyncio.get_event_loop()
    res = loop.run_until_complete(asyncio.wait([buy_potatos(), buy_tomatos()]))
    loop.close()


if __name__=="__main__":
    import time
    begin_time=time.time()
    main()
    end_time=time.time()
    print("耗时是:%s秒"%(end_time-begin_time))

 

运行结果:

开始制造 5 个土豆
制造第[0]土豆
制造第[1]土豆
制造第[2]土豆
制造第[3]土豆
制造第[4]土豆
开始制造 5 个西红柿
制造第[0]西红柿
制造第[1]西红柿
制造第[2]西红柿
制造第[3]西红柿
制造第[4]西红柿
取到西红柿: 140473681858176...
取到西红柿: 140473681857504...
取到西红柿: 140473681857448...
取到西红柿: 140473681857560...
取到西红柿: 140473681857168...
开始进行挂起,上架西红柿
开始进行挂起,生产7个西红柿
接下来遇到io等待,运行其他协程函数
取到土豆: 140473681857112...
取到土豆: 140473681855768...
取到土豆: 140473681855712...
取到土豆: 140473743063304...
取到土豆: 140473743062688...
开始进行挂起,上架土豆
开始进行挂起,生产7个土豆
接下来遇到io等待,运行其他协程函数
开始制造 7 个西红柿
制造第[0]西红柿
制造第[1]西红柿
制造第[2]西红柿
制造第[3]西红柿
制造第[4]西红柿
制造第[5]西红柿
制造第[6]西红柿
已经完成7个西红柿的生产
取到西红柿: 140473681877928...
取到西红柿: 140473681877872...
取到西红柿: 140473681877816...
取到西红柿: 140473681877760...
取到西红柿: 140473681877592...
取到西红柿: 140473681877648...
取到西红柿: 140473681877704...
开始进行挂起,上架西红柿
开始进行挂起,生产10个西红柿
接下来遇到io等待,运行其他协程函数
开始制造 7 个土豆
制造第[0]土豆
制造第[1]土豆
制造第[2]土豆
制造第[3]土豆
制造第[4]土豆
制造第[5]土豆
制造第[6]土豆
已经完成7个土豆的生产
取到土豆: 140473681878320...
取到土豆: 140473681878264...
取到土豆: 140473681878208...
取到土豆: 140473681878152...
取到土豆: 140473681878096...
取到土豆: 140473681878040...
取到土豆: 140473681877984...
开始进行挂起,上架土豆
开始进行挂起,生产9个土豆
接下来遇到io等待,运行其他协程函数
开始制造 9 个土豆
制造第[0]土豆
制造第[1]土豆
制造第[2]土豆
制造第[3]土豆
制造第[4]土豆
制造第[5]土豆
制造第[6]土豆
制造第[7]土豆
制造第[8]土豆
已经完成9个土豆的生产
取到土豆: 140473681878824...
取到土豆: 140473681878768...
取到土豆: 140473681878712...
取到土豆: 140473681878656...
取到土豆: 140473681878600...
取到土豆: 140473681878544...
取到土豆: 140473681878488...
取到土豆: 140473681878432...
取到土豆: 140473681878376...
开始进行挂起,上架土豆
开始进行挂起,生产9个土豆
接下来遇到io等待,运行其他协程函数
开始制造 10 个西红柿
制造第[0]西红柿
制造第[1]西红柿
制造第[2]西红柿
制造第[3]西红柿
制造第[4]西红柿
制造第[5]西红柿
制造第[6]西红柿
制造第[7]西红柿
制造第[8]西红柿
制造第[9]西红柿
已经完成10个西红柿的生产
取到西红柿: 140473670754712...
取到西红柿: 140473670754656...
取到西红柿: 140473670754600...
取到西红柿: 140473670754544...
取到西红柿: 140473670754488...
取到西红柿: 140473670754432...
取到西红柿: 140473670754376...
取到西红柿: 140473681878992...
取到西红柿: 140473681878936...
取到西红柿: 140473681878880...
开始进行挂起,上架西红柿
开始进行挂起,生产7个西红柿
接下来遇到io等待,运行其他协程函数
开始制造 7 个西红柿
制造第[0]西红柿
制造第[1]西红柿
制造第[2]西红柿
制造第[3]西红柿
制造第[4]西红柿
制造第[5]西红柿
制造第[6]西红柿
已经完成7个西红柿的生产
取到西红柿: 140473670755104...
取到西红柿: 140473670755048...
取到西红柿: 140473670754992...
取到西红柿: 140473670754936...
取到西红柿: 140473670754880...
取到西红柿: 140473670754824...
取到西红柿: 140473670754768...
开始进行挂起,上架西红柿
开始进行挂起,生产7个西红柿
接下来遇到io等待,运行其他协程函数
开始制造 9 个土豆
制造第[0]土豆
制造第[1]土豆
制造第[2]土豆
制造第[3]土豆
制造第[4]土豆
制造第[5]土豆
制造第[6]土豆
制造第[7]土豆
制造第[8]土豆
已经完成9个土豆的生产
取到土豆: 140473670755608...
取到土豆: 140473670755552...
取到土豆: 140473670755496...
取到土豆: 140473670755440...
取到土豆: 140473670755384...
取到土豆: 140473670755328...
取到土豆: 140473670755272...
取到土豆: 140473670755216...
取到土豆: 140473670755160...
开始进行挂起,上架土豆
开始进行挂起,生产8个土豆
接下来遇到io等待,运行其他协程函数
开始制造 7 个西红柿
制造第[0]西红柿
制造第[1]西红柿
制造第[2]西红柿
制造第[3]西红柿
制造第[4]西红柿
制造第[5]西红柿
制造第[6]西红柿
已经完成7个西红柿的生产
取到西红柿: 140473670756000...
取到西红柿: 140473670755944...
取到西红柿: 140473670755888...
取到西红柿: 140473670755832...
取到西红柿: 140473670755776...
取到西红柿: 140473670755720...
取到西红柿: 140473670755664...
开始进行挂起,上架西红柿
开始进行挂起,生产1个西红柿
接下来遇到io等待,运行其他协程函数
开始制造 1 个西红柿
制造第[0]西红柿
已经完成1个西红柿的生产
取到西红柿: 140473670756056...
开始进行挂起,上架西红柿
开始进行挂起,生产4个西红柿
接下来遇到io等待,运行其他协程函数
开始制造 8 个土豆
制造第[0]土豆
制造第[1]土豆
制造第[2]土豆
制造第[3]土豆
制造第[4]土豆
制造第[5]土豆
制造第[6]土豆
制造第[7]土豆
已经完成8个土豆的生产
取到土豆: 140473670756504...
取到土豆: 140473670756448...
取到土豆: 140473670756392...
取到土豆: 140473670756336...
取到土豆: 140473670756280...
取到土豆: 140473670756224...
取到土豆: 140473670756168...
取到土豆: 140473670756112...
开始进行挂起,上架土豆
开始进行挂起,生产5个土豆
接下来遇到io等待,运行其他协程函数
开始制造 4 个西红柿
制造第[0]西红柿
制造第[1]西红柿
制造第[2]西红柿
制造第[3]西红柿
已经完成4个西红柿的生产
取到西红柿: 140473670756728...
取到西红柿: 140473670756672...
取到西红柿: 140473670756616...
取到西红柿: 140473670756560...
开始进行挂起,上架西红柿
开始进行挂起,生产1个西红柿
接下来遇到io等待,运行其他协程函数
开始制造 1 个西红柿
制造第[0]西红柿
已经完成1个西红柿的生产
取到西红柿: 140473670756784...
开始进行挂起,上架西红柿
开始进行挂起,生产2个西红柿
接下来遇到io等待,运行其他协程函数
开始制造 5 个土豆
制造第[0]土豆
制造第[1]土豆
制造第[2]土豆
制造第[3]土豆
制造第[4]土豆
已经完成5个土豆的生产
取到土豆: 140473670757064...
取到土豆: 140473670757008...
取到土豆: 140473670756952...
取到土豆: 140473670756896...
取到土豆: 140473670756840...
开始进行挂起,上架土豆
开始进行挂起,生产10个土豆
接下来遇到io等待,运行其他协程函数
开始制造 2 个西红柿
制造第[0]西红柿
制造第[1]西红柿
已经完成2个西红柿的生产
取到西红柿: 140473670757176...
取到西红柿: 140473670757120...
开始进行挂起,上架西红柿
开始进行挂起,生产9个西红柿
接下来遇到io等待,运行其他协程函数
开始制造 10 个土豆
制造第[0]土豆
制造第[1]土豆
制造第[2]土豆
制造第[3]土豆
制造第[4]土豆
制造第[5]土豆
制造第[6]土豆
制造第[7]土豆
制造第[8]土豆
制造第[9]土豆
已经完成10个土豆的生产
取到土豆: 140473670757736...
取到土豆: 140473670757680...
取到土豆: 140473670757624...
取到土豆: 140473670757568...
取到土豆: 140473670757512...
取到土豆: 140473670757456...
取到土豆: 140473670757400...
开始制造 9 个西红柿
制造第[0]西红柿
制造第[1]西红柿
制造第[2]西红柿
制造第[3]西红柿
制造第[4]西红柿
制造第[5]西红柿
制造第[6]西红柿
制造第[7]西红柿
制造第[8]西红柿
已经完成9个西红柿的生产
取到西红柿: 140473681878152...
取到西红柿: 140473681878208...
取到西红柿: 140473681878264...
取到西红柿: 140473681878320...
取到西红柿: 140473743062688...
取到西红柿: 140473743063304...
耗时是:48.02546787261963秒

 

参考资料:

https://www.cnblogs.com/dhcn/p/9032461.html