1.同步

#引用時間片段，系統
import time
import os

#同步程序阻塞
def rep_a():
    print("開始請求處理rep_a");
    time.sleep(5)
    print("完成處理rep_a");

def rep_b():
    print("開始請求處理rep_b");
    print("完成請求處理rep_b");
#主函式呼叫a，b函式，先呼叫a
def main():
    rep_a();
    rep_b();

if __name__ == "__main__":
    main()

執行時候只有a執行完之後才能執行b，在這裡使a休眠五秒種時候，b函式只有等待
執行結果：

import time
from threading import Thread
def long_io(callback):
    def fun(cb):
        print("開始執行IO操作..."
 
);
        time.sleep(5);
        print("完成IO操作，並執行回撥函式...")
        #執行回撥函式
        cb("io result")
    #開區執行緒執行耗時操作
    t=Thread(target=fun,args=(callback,))
    t.start()

def on_finish(ret):
    print("開始執行回撥函式on_finish")
    # ret=yield long_io()
    print("ret: %s "% ret);
    print("完成執行回撥函式on_finish"
 
)

def rep_a():
    print("開始處理請求rep_a");
    #呼叫long_io函式
    long_io(on_finish);
    print("離開處理請求rep_a");

def rep_b():
    print("開始處理請求rep_b")
    time.sleep(2);
    print("完成處理請求rep_b")

def main():
    rep_a();
    rep_b();
    #在這裡加了一個while使函式進入一個死迴圈，防止程式執行停止
    while 1:
        pass;


if __name__ == "__main__":
    main()

執行結果如下：

3.函式的協程，在使用回撥函式寫非同步程式時，需將本屬於一個執行邏輯（處理請求a）的程式碼拆分成兩個函式req_a和on_finish，這與同步程式的寫法相差很大。

import time
from threading import Thread

#全域性生成器，供long_io使用
gen = None;

def long_io():
    def fun():
        print("開始執行IO操作");
        global gen;
        time.sleep(5);
        try:
            print("完成IO操作，並sent結果喚醒掛起程式繼續執行")
            gen.send("io result")
        except Exception as e:
            pass;
    t=Thread(target=fun,args=());
    t.start();

def req_a():
    print("開始處理請求rep_a");
    ret = yield long_io();
    print("ret: %s "%ret);
    print("完成處理請求rep_a");

def req_b():
    print("開始請求處理req_b");
    time.sleep(2);
    print("完成處理rep_b");

def main():
    global gen;
    gen=req_a();
    next(gen);
    req_b();
    #如果不想一直迴圈可以把while注掉
    # while 1:
    #     pass

if  __name__ == "__main__":

    main()

執行結果如下