python多线程、线程锁

1、python多线程

多线程可以把空闲时间利用起来

比如有两个进程函数 func1、func2，func1函数里使用sleep休眠一定时间，如果使用单线程调用这两个函数，那么会顺序执行这两个函数

也就是直到第一个函数执行完后，才会执行第二个函数，这样需要很长时间；

如果使用多线程，会发现这两个函数是同时执行的，这是因为多线程会把空闲的时间利用起来，在第一个函数休眠的函数就开始执行第二个函数

实例：

import _thread as thread
from time import sleep, ctime

def fun1():
    print('开始运行func1', ctime())
    # 休眠4秒
    sleep(4)
    print('func1运行结束', ctime())
def fun2():
    print('开始运行func2', ctime())
    # 休眠4秒
    sleep(2)
    print('func2运行结束', ctime())
def main():
    print('开始运行时间', ctime())
    # 启动一个线程运行func1函数
    thread.start_new_thread(fun1, ())
    thread.start_new_thread(fun2, ())
    # 休眠6秒
    sleep(6)
    print('运行结束时间', ctime())

if __name__ == '__main__':
    main()

E:\python\python.exe E:/progect/untitled1/untitled1/urls.py
开始运行时间 Sat Feb 16 09:34:00 2019
开始运行func1 Sat Feb 16 09:34:00 2019
开始运行func2 Sat Feb 16 09:34:00 2019
func2运行结束 Sat Feb 16 09:34:02 2019
func1运行结束 Sat Feb 16 09:34:04 2019
运行结束时间 Sat Feb 16 09:34:06 2019



2、线程和锁

第一种

这里的锁并不是把程序锁住不退出，而是通过锁可以让程序了解是否还有线程函数没有执行，而且可以做到当所有的线程函数执行完后，

程序会立刻退出，

allocate_lock 函数创建锁对象，然后使用锁对象的acquire方法获取锁，如果不需要锁了，可以使用锁对象的release方法释放锁，

如果判断锁是否被释放可以使用锁对象的locked方法


第二种

还可以使用Thread对象的join方法等待函数执行完毕再往下执行；等待所有线程函数都执行完毕后再推出程序（一般用这个）

实例：

import threading
from time import sleep,ctime
def fun(index,sec):
    print('开始执行',index,'时间',ctime())
    sleep(sec)
    print('执行结束',index,'时间',ctime())
def main():
    #创建第1个Thread类，通过target关键字参数指定线程函数fun，传入索引10和休眠时间（4s）
    thread1=threading.Thread(target=fun,args=(10,4))
    #启动第1个线程
    thread1.start()
    #创建第2个Thread类，通过target关键字参数指定线程函数fun，传入索引20和休眠时间（2s）
    thread2=threading.Thread(target=fun,args=(20,2))
    #启动第2个线程
    thread2.start()
    #等待第1个线程函数执行完毕
    thread1.join()
    #等待第2个线程函数执行完毕
    thread2.join()
if __name__ == '__main__':
    main()

E:\python\python.exe E:/progect/untitled1/untitled1/urls.py
开始执行 10 时间 Sat Feb 16 09:03:48 2019
开始执行 20 时间 Sat Feb 16 09:03:48 2019
执行结束 20 时间 Sat Feb 16 09:03:50 2019
执行结束 10 时间 Sat Feb 16 09:03:52 2019