Thread创建线程，Lock互斥锁
from threading import Thread,Lock
xx = Thread(target=函数名)
xx.start() #执行线程
5个线程一起执行
import threading
import time
def saySory():
print("品爱的，我错了")
time.sleep(1)
if __name__ == '__main__':
for i in range(5):
#创建线程执行
t = threading.Thread(target=saySory)
#开始执行
t.start()
进程里面套线程
进程是资源分配的单位，线程是CPU调度的单位
主线程会等待所有子线程结束才结束
import threading
from time import sleep,ctime
def sing():
for i in range(3):
print("正在唱歌...%d"%i)
sleep(1)
def dance():
for i in range(3):
print("正在跳舞...%d"%i)
sleep(1)
if __name__ == "__main__":
print('---开始---')
#主线程会等待所有子线程结束才结束
t1 = threading.Thread(target = sing)
t2 = threading.Thread(target = dance)
t1.start()
t2.start()
print("---结束---")
类方法
1个线程执行
#单线程执行
import threading
import time
class MyThread(threading.Thread):
def run(self):
for i in range(3):
time.sleep(1)
msg = "线程名字：%s,%s"%(self.name,i)
print(msg)
if __name__ == "__main__":
t = MyThread()
t.start()
5个线程执行执行一个方法
import threading
import time
class MyThread(threading.Thread):
def run(self):
for i in range(5):
msg = "线程名字：%s，%s"%(self.name,i)
print(msg)
def test():
for i in range(5):
t = MyThread()
t.start()
if __name__ == "__main__":
test()
多进程全局变量不共享
多线程全局变量是共享的
互斥锁
创建锁：mutex = threading.Lock()
锁定：mutex.acquire([blocking])
释放：mutex.release()
其中，锁定发放acquire可以有一个blocking参数
- 如果设定blocking为True，则当前线程堵塞，直到获取到这个锁为止(如果没有指定，那么默认为True)
- 如果设定blocking为False，则当前线程不会堵塞
互斥锁代码：
from threading import Thread,Lock
import time
g_num = 0
def work1():
global g_num
#这个线程和work2线程都在抢着，如果有一方成功的上锁
#那么导致另外一方会堵塞(一直等待)到这个锁被解开为止
#上锁
mutex.acquire()
for i in range(1000000):
g_num += 1
#执行完上面代码解锁
mutex.release()
print("work1:%d"%g_num)
def work2():
global g_num
#上锁
mutex.acquire()
for i in range(1000000):
g_num += 1
#解锁
mutex.release()
print("work2:%d"%g_num)
#创建一把互斥锁
mutex = Lock()
if __name__ == "__main__":
t1 = Thread(target=work1)
t2 = Thread(target=work2)
t1.start()
t2.start()
锁的好处：
确保了某段关键代码只能由一个线程从头到尾完整地执行
锁得坏处：
1.阻止了多线程并发执行，包含锁的某段代码实际上只能以单线程模式执行，效率就大大地下降了
2.由于可以存在多个锁，不同的线程持有不同的锁，并试图获取对方持有的锁时，可能会造成死锁
