线程的数据安全
1 数据混乱现象
from threading import Thread,Lock num = 0 lst = [] def func1(): global num for i in range(100000): num -= 1 def func2(): global num for i in range(100000): num += 1 for i in range (10): # 启动线程1 t1 = Thread(target=func1) t1.start() # 启动线程2 t2 = Thread(target=func2) t2.start() lst.append(t1) lst.append(t2) for i in lst: i.join() print("主线程执行结束") print(num)
执行
由于共享同一份，会出现数据混乱，如下结果
[root@node10 python]# python3 test.py 主线程执行结束 173624 [root@node10 python]# python3 test.py 主线程执行结束 131875 [root@node10 python]# python3 test.py 主线程执行结束 -4279 [root@node10 python]# python3 test.py 主线程执行结束 -93587 [root@node10 python]# python3 test.py 主线程执行结束 145643
这是因为线程是并发执行，同同一时间会有多个线程拿到同一个数据进行计算，然后再放回去，导致一个数字被多个线程修改，结果不准确
2 引入锁机制
from threading import Thread,Lock num = 0 lst = [] def func1(lock): global num for i in range(100000): #上锁修改数据 lock.acquire() num -= 1 #解锁释放 lock.release() def func2(lock): global num for i in range(100000): #使用with，自动上锁和解锁 with lock: num += 1 lock = Lock() for i in range (10): # 启动线程1 t1 = Thread(target=func1,args=(lock,)) t1.start() # 启动线程2 t2 = Thread(target=func2,args=(lock,)) t2.start() lst.append(t1) lst.append(t2) for i in lst: i.join() print("主线程执行结束") print(num)
执行
[root@node10 python]# python3 test.py 主线程执行结束 0
结果正确，但是消耗的时间毕竟长，但是可以换取数据正确
3 信号量
import time,random,os def func(i,sem): time.sleep(random.uniform(0.1,1)) with sem: print (i) print (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())) time.sleep(random.uniform(3,6)) sem = Semaphore(5) for i in range (20): Thread(target = func,args=(i,sem)).start()
执行
[root@node10 python]# python3 test.py 3 2020-02-23 03:55:24 5 2020-02-23 03:55:24 14 2020-02-23 03:55:24 18 2020-02-23 03:55:24 6 2020-02-23 03:55:24 0 2020-02-23 03:55:27 2 2020-02-23 03:55:29 15 2020-02-23 03:55:29 1 2020-02-23 03:55:29 19 2020-02-23 03:55:30 12 2020-02-23 03:55:32 4 2020-02-23 03:55:32 17 2020-02-23 03:55:34 16 2020-02-23 03:55:34 13 2020-02-23 03:55:35 7 2020-02-23 03:55:36 10 2020-02-23 03:55:36 8 2020-02-23 03:55:39 9 2020-02-23 03:55:39 11 2020-02-23 03:55:40
信号量就相当于同时可以上多把锁
死锁,递归锁,互斥锁
4 死锁现象
模拟一个俱乐部玩枪，两把枪，两盒子弹，四个人同时抢，只有同时抢到子弹和枪的人，才能玩枪
初步逻辑
from threading import Thread,Lock import time #首先创建两把锁 gun = Lock() bullet = Lock() #定义第一种，先抢到枪，再抢到子弹 def play1(name): #抢到枪，上锁 gun.acquire() print("%s拿到枪"%(name)) #抢到子弹上锁 bullet.acquire() print ("%s抢到子弹"%(name)) print ("开枪玩一会") time.sleep(0.5) #放下枪，解锁 gun.release() print("%s放下枪"%(name)) #放下子弹，解锁 bullet.release() print("%s放下子弹"%(name)) #定义第二种，先抢到子弹，再抢到枪 def play2(name): #抢到子弹上锁 bullet.acquire() print ("%s抢到子弹"%(name)) #抢到枪，上锁 gun.acquire() print("%s拿到枪"%(name)) print ("开枪玩一会") time.sleep(0.5) #放下子弹，解锁 bullet.release() print("%s放下子弹"%(name)) #放下枪，解锁 gun.release() print("%s放下枪"%(name)) name_lst1 = ["John","Jim"] name_lst2 = ["Tom","Jerry"] for name in name_lst1: Thread(target=play1,args=(name,)).start() for name in name_lst2: Thread(target=play2,args=(name,)).start()
这种情况就会有死锁现象
多次执行，结果如下
[root@node10 python]# python3 test.py John拿到枪 Tom抢到子弹 #阻塞，是因为John和Tom同时上了枪锁和子弹锁，但是都没有解锁，造成死锁 [root@node10 python]# python3 test.py John拿到枪 John抢到子弹 开枪玩一会 John放下枪 John放下子弹 Jim拿到枪 Tom抢到子弹 #阻塞，这次是John顺利的玩一局，但是到Jim和Tom同时抢到枪和子弹，上锁，但是没有解锁，造成死锁 [root@node10 python]# python3 test.py John拿到枪 John抢到子弹 开枪玩一会 John放下枪 John放下子弹 Tom抢到子弹 Jim拿到枪 #阻塞
5 递归锁介绍
上几把锁，解几把锁
from threading import Thread,RLock rlock = RLock() def func(name): rlock.acquire() print(name,1) rlock.acquire() print(name,2) rlock.acquire() print(name,3) rlock.release() rlock.release() rlock.release() for i in range(10): t = Thread(target=func,args=("name%s" % (i),) ) t.start() print("程序执行结束")
执行
[root@node10 python]# python3 ceshi.py name0 1 name0 2 name0 3 name1 1 name1 2 name1 3 name2 1 name2 2 name2 3 name3 1 name3 2 name3 3 程序执行结束 name4 1 name4 2 name4 3 name5 1 name5 2 name5 3 name6 1 name6 2 name6 3 name7 1 name7 2 name7 3 name8 1 name8 2 name8 3 name9 1 name9 2 name9 3
6 利用递归锁,解决死锁现象
临时用于快速解决服务器崩溃死锁的问题,用递归锁应急问题
from threading import Thread,RLock import time #首先创建递归锁 gun=bullet = RLock() #定义第一种，先抢到枪，再抢到子弹 def play1(name): #抢到枪，上锁 gun.acquire() print("%s拿到枪"%(name)) #抢到子弹上锁 bullet.acquire() print ("%s抢到子弹"%(name)) print ("开枪玩一会") time.sleep(0.5) #放下枪，解锁 gun.release() print("%s放下枪"%(name)) #放下子弹，解锁 bullet.release() print("%s放下子弹"%(name)) #定义第二种，先抢到子弹，再抢到枪 def play2(name): #抢到子弹上锁 bullet.acquire() print ("%s抢到子弹"%(name)) #抢到枪，上锁 gun.acquire() print("%s拿到枪"%(name)) print ("开枪玩一会") time.sleep(0.5) #放下子弹，解锁 bullet.release() print("%s放下子弹"%(name)) #放下枪，解锁 gun.release() print("%s放下枪"%(name)) name_lst1 = ["John","Jim"] name_lst2 = ["Tom","Jerry"] for name in name_lst1: Thread(target=play1,args=(name,)).start() for name in name_lst2: Thread(target=play2,args=(name,)).start()
执行
[root@node10 python]# python3 test.py John拿到枪 John抢到子弹 开枪玩一会 John放下枪 John放下子弹 Jim拿到枪 Jim抢到子弹 开枪玩一会 Jim放下枪 Jim放下子弹 Tom抢到子弹 Tom拿到枪 开枪玩一会 Tom放下子弹 Tom放下枪 Jerry抢到子弹 Jerry拿到枪 开枪玩一会 Jerry放下子弹 Jerry放下枪
执行成功，神奇
7 使用互斥锁解决
从语法上来看,锁是可以互相嵌套的,但是不要使用
上一次锁,就对应解开一把锁,形成互斥锁
拿枪和拿子弹是同时的,上一把锁就够了,不要分开上锁，也不要去写锁的嵌套,容易死锁
from threading import Thread,Lock import time #首先创建递归锁 mylock = Lock() #定义第一种，先抢到枪，再抢到子弹 def play1(name): #抢到枪和子弹，上锁 mylock.acquire() print("%s拿到枪"%(name)) print ("%s抢到子弹"%(name)) print ("开枪玩一会") time.sleep(0.5) #放下枪，和子弹解锁 print("%s放下枪"%(name)) print("%s放下子弹"%(name)) mylock.release() #定义第二种，先抢到子弹，再抢到枪 def play2(name): #抢到枪子弹上锁 mylock.acquire() print ("%s抢到子弹"%(name)) print("%s拿到枪"%(name)) print ("%s开枪玩一会"%(name)) time.sleep(0.5) #放枪下子弹，解锁 print("%s放下子弹"%(name)) print("%s放下枪"%(name)) mylock.release() name_lst1 = ["John","Jim"] name_lst2 = ["Tom","Jerry"] for name in name_lst1: Thread(target=play1,args=(name,)).start() for name in name_lst2: Thread(target=play2,args=(name,)).start()
执行
[root@node10 python]# python3 test.py John拿到枪 John抢到子弹 开枪玩一会 John放下枪 John放下子弹 Jim拿到枪 Jim抢到子弹 开枪玩一会 Jim放下枪 Jim放下子弹 Tom抢到子弹 Tom拿到枪 Tom开枪玩一会 Tom放下子弹 Tom放下枪 Jerry抢到子弹 Jerry拿到枪 Jerry开枪玩一会 Jerry放下子弹 Jerry放下枪
完成