python 异步 文件io python异步orm

近期学到了python的同步和异步处理，跟大家分享一下，希望能够带大家理解一下同步和异步。下面我举一个例子：

同步

import time


def work1():
    for i in range(5):
        time.sleep(1)
        print("work1-打孔--{}".format(i))


def work2():
    for i in range(6):
        time.sleep(1)
        print("work2--浇花-{}".format(i))


if __name__ == '__main__':
    s_t = time.time()
    work1()
    work2()
    e_t = time.time()
    print(e_t - s_t)



执行结果：
work1-打孔--0
work1-打孔--1
work1-打孔--2
work1-打孔--3
work1-打孔--4
work2--浇花-0
work2--浇花-1
work2--浇花-2
work2--浇花-3
work2--浇花-4
work2--浇花-5
11.00449013710022

这里执行了work1() 和 work2()，还有从开始执行到结束执行共计用了多长时间。执行结果我贴在了上面。从执行结果看：可以看出来1点：
1、先执行完work1()，work1()执行完毕后才会去执行work2()函数，最后执行结束之后计算了总共花了11.00449013710022秒。

异步

import time
from threading import Thread


def work1():
    for i in range(5):
        time.sleep(1)
        print("work1-打孔--{}".format(i))


def work2():
    for i in range(6):
        time.sleep(1)
        print("work2--浇花-{}".format(i))


def work3():
    for i in range(6):
        time.sleep(1)
        print("work3--写代码-{}".format(i))


if __name__ == '__main__':
    s_t = time.time()
    # 创建一个线程
    t1 = Thread(target=work1)
    t1.start()
    # 创建一个线程：
    t2 = Thread(target=work2)
    t2.start()
    # 创建一个线程：
    t3 = Thread(target=work3)
    t3.start()

   
    e_t = time.time()
    print(e_t - s_t)




执行结果:
0.0003390312194824219
work1-打孔--0
work2--浇花-0
work3--写代码-0
work1-打孔--1work2--浇花-1

work3--写代码-1
work1-打孔--2
work3--写代码-2work2--浇花-2

work1-打孔--3
work2--浇花-3
work3--写代码-3
work1-打孔--4work2--浇花-4work3--写代码-4


work3--写代码-5
work2--浇花-5

这个时候你会发现：
1、3个函数同时在跑。

2、他直接打印了时长，其他线程还在跑。是因为主线程不会等待子线程跑完然后再去执行。

大家可以理解为 打孔、浇花、写代码我都得同时进行，那我一个人忙不过来咋办呢？我这个时候就喊了2个小伙伴（添加了2个子线程），那这个时候我们就能一起干活了！进而任务完全完成发现才6秒几（看下图）

下面我们就得想怎么让线程跑完后再去执行计算时长这个代码。

import time
from threading import Thread


def work1():
    for i in range(5):
        time.sleep(1)
        print("work1-打孔--{}".format(i))


def work2():
    for i in range(6):
        time.sleep(1)
        print("work2--浇花-{}".format(i))


def work3():
    for i in range(6):
        time.sleep(1)
        print("work3--写代码-{}".format(i))


if __name__ == '__main__':
    s_t = time.time()
    # 创建一个线程
    t1 = Thread(target=work1)
    t1.start()
    # 创建一个线程：
    t2 = Thread(target=work2)
    t2.start()
    # 创建一个线程：
    t3 = Thread(target=work3)
    t3.start()

    主线程等待子线程执行
    t1.join()
    t2.join()
    t3.join()
    e_t = time.time()
    print(e_t - s_t)




打印结果:
work2--浇花-0work1-打孔--0

work3--写代码-0
work2--浇花-1
work1-打孔--1
work3--写代码-1
work2--浇花-2
work1-打孔--2
work3--写代码-2
work1-打孔--3work2--浇花-3

work3--写代码-3
work2--浇花-4
work1-打孔--4
work3--写代码-4
work2--浇花-5
work3--写代码-5
6.004496335983276

不难发现，我在后面添加了t1.join()，t2.join()，t3.join()，这就是我设置了等待该子线程执行结束后再执行下面的代码。大家理解了吗。

Thread(target=指定线程执行的任务函数)：创建线程

Thread.start() :启动线程

注意点：默认的情况下主线程时不会等待子线程执行的

Thread.join():设置主线程等待子线程执行的时间
 join不传参数默认等待改子线程执行结束，可以通过参数设置指定的等待时间