首页 » 编程 » Python-7.并发编程 » 正文

异步调用与回调机制

提交任务的两种方式:

1. 同步调用:提交完任务后,就在原地等待任务执行完毕,拿到结果,再执行下一步代码,导致程序是串行执行。

来看一个拉粑粑的例子:

from concurrent.futures import ThreadPoolExecutor
import time, random


def la(name):
    print("%s 正在拉..." % name)
    time.sleep(random.randint(3, 5))  # 模拟拉的时间
    res = random.randint(7, 13) * "#"  # 模拟拉的数量,随机的"#"字符串
    return {"name": name, "res": res}


def weigh(shit):
    name = shit["name"]
    size = len(shit["res"])  # 获取粑粑的大小
    print("%s 拉了 %s kg" % (name, size))


if __name__ == '__main__':
    pool = ThreadPoolExecutor(13)  # 定义一个池,可同时处理13个人一起拉

    shit1 = pool.submit(la, "alex").result()  # 提交alex去拉
    weigh(shit1)  # 将alex拉的结果去称重

    shit2 = pool.submit(la, "wupeiqi").result()
    weigh(shit2)

    shit3 = pool.submit(la, "yuanhao").result()
    weigh(shit3)

运行结果:

alex 正在拉...
alex 拉了 8 kg
wupeiqi 正在拉...
wupeiqi 拉了 7 kg
yuanhao 正在拉...
yuanhao 拉了 13 kg

可以看出:上面例子其实是在串行运行,并不高效,需要等待1个人拉了之后,下一个人才能够拉。

我们使用异步调用方式来改写一下。

 

2. 异步调用:提交完任务后,不在原地等待任务执行完毕。

from concurrent.futures import ThreadPoolExecutor
import time, random


def la(name):
    print("%s 正在拉..." % name)
    time.sleep(random.randint(3, 5))  # 模拟拉的时间
    res = random.randint(7, 13) * "#"  # 模拟拉的数量,随机的"#"字符串
    # return {"name": name, "res": res}
    weigh({"name": name, "res": res})  # 谁先拉完,就将拉的结果提交称重


def weigh(shit):
    name = shit["name"]
    size = len(shit["res"])  # 获取粑粑的大小
    print("%s 拉了 %s kg" % (name, size))


if __name__ == '__main__':
    pool = ThreadPoolExecutor(13)  # 定义一个池,可同时处理13个人一起拉

    pool.submit(la, "alex")  # 提交alex去拉
    pool.submit(la, "wupeiqi")  # 提交wupeiqi去拉
    pool.submit(la, "yuanhao")  # 提交yuanhao去拉

运行结果:

alex 正在拉...
wupeiqi 正在拉...
yuanhao 正在拉...
wupeiqi 拉了 8 kg  #wupeiqi先拉完进行称重有8kg
alex 拉了 12 kg #alex第二拉完,拉了12kg
yuanhao 拉了 12 kg #yuanhao第三拉完,也拉了12kg

可以看出:程序运行就同时提交3个人去拉,谁先拉完就去称重,然后打印称重结果,变的高效起来了。

 

由于提交拉的请求到池后,提交的就得不到结果了,所以在拉的函数里就直接将结果传给了称重函数,逻辑没有问题,但是耦合性变高了,不好,所以需要解耦,我们再来改一下,还是要实现谁先拉完谁就自动去称重,需要用到回调函数来实现。

from concurrent.futures import ThreadPoolExecutor
import time, random


def la(name):
    print("%s 正在拉..." % name)
    time.sleep(random.randint(3, 5))  # 模拟拉的时间
    res = random.randint(7, 13) * "#"  # 模拟拉的数量,随机的"#"字符串
    return {"name": name, "res": res}


def weigh(shit):
    shit = shit.result()  # 通过回调函数传进来的是一个future对象,需要通过result()获取到值
    name = shit["name"]
    size = len(shit["res"])  # 获取粑粑的大小
    print("%s 拉了 %s kg" % (name, size))


if __name__ == '__main__':
    pool = ThreadPoolExecutor(13)  # 定义一个池,可同时处理13个人一起拉

    pool.submit(la, "alex").add_done_callback(weigh)  # 提交alex去拉,拉完后自动调用weigh函数并将拉的结果传给weigh
    pool.submit(la, "wupeiqi").add_done_callback(weigh)  # 提交wupeiqi去拉,拉完后自动调用weigh函数并将拉的结果传给weigh
    pool.submit(la, "yuanhao").add_done_callback(weigh)  # 提交yuanhao去拉,拉完后自动调用weigh函数并将拉的结果传给weigh

运行结果:

alex 正在拉...
wupeiqi 正在拉...
yuanhao 正在拉...
wupeiqi 拉了 7 kg
yuanhao 拉了 9 kg
alex 拉了 13 kg

可以看出:运行结果和之前的一样,并且实现了解耦。

 

阻塞:指的是进程运行的一种状态,当进程运行时遇到IO了就会进入阻塞状态,会被剥夺走CPU的执行权限。

非阻塞:与阻塞相反。

 

 

 

发表评论

*