多个线程锁

新学

为什么多把锁反而无法禁止线程的切换

1. 
   
2. 
   
3. from threading import Thread, Lock, enumerate
   
4. 
   
5. # 共用一把锁
   
6. lock = Lock()
   
7. class Sum1(Thread):
   
8.     sum = 0
   
9.     def __init__(self, n):
   
10.         super().__init__()
    
11.         self.n = n
    
12. 
    
13.     def run(self):
    
14.         for i in range(self.n):
    
15.             lock.acquire()  # 上锁，上锁后禁止cpu切换线程
    
16.             Sum1.sum += 1
    
17.             lock.release()  # 开锁，允许cpu切换线程
    
18.         print(Sum1.sum)
    
19. 
    
20. 
    
21. # 多个锁：每个对象都用自己的锁
    
22. class Sum2(Thread):
    
23.     sum = 0
    
24.     def __init__(self, n):
    
25.         super().__init__()
    
26.         self.n = n
    
27. 
    
28.     def run(self):
    
29.         lock1 = Lock()  # 用自己的锁
    
30.         for i in range(self.n):
    
31.             lock1.acquire()  # 上锁，上锁后禁止cpu切换线程
    
32.             Sum2.sum += 1
    
33.             lock1.release()  # 开锁，允许cpu切换线程
    
34.         print(Sum2.sum)
    
35. 
    
36. def main():
    
37.     n = 100000
    
38. 
    
39.     t1 = Sum1(n)  # Sum1公用一把锁
    
40.     t2 = Sum1(n)
    
41.     t3 = Sum1(n)
    
42. 
    
43.     # t1 = Sum2(n) # Sum2对象用自己的锁
    
44.     # t2 = Sum2(n)
    
45.     # t3 = Sum2(n)
    
46. 
    
47.     t1.start()
    
48.     t2.start()
    
49.     t3.start()
    
50. 
    
51. 
    
52. if __name__ == '__main__':
    
53.     main()
    
54. 
    
55. 
    
56. """
    
57. 运行结果：
    
58. 共用一把锁时：
    
59. 261921
    
60. 285610
    
61. 300000
    
62. 多把锁时： # 随机的数据 线程在被锁住的地方切换了
    
63. 194130
    
64. 199063
    
65. 225863
    
66. """
    

复制代码

suchocolate

1）Lock是锁定共享的全局变量，某线程使用时不让其他线程修改，其他线程想修改得等待线程用完，为的是数据的唯一性，并不是所谓的‘锁cpu线程切换’。
2）你的代码循环间隙就释放了锁，别的线程会抢间隙时间修改，要改成这样：

1.     def run(self):
   
2.         lock.acquire()  # 上锁，上锁后禁止其他线程访问
   
3.         for item in range(self.n):
   
4.             sum1.sum += 1
   
5.         print(sum1.sum)
   
6.         lock.release()  # 开锁，允许其他线程访问
   

复制代码

3）‘多把锁’没有意义，想保持数据的唯一性，就得用一把锁。线程锁是君子协定，如果有的线程错配置没有用同一把锁，是可以修改的，这就会造成混乱。打个比方，现在有2个线程：线程A和线程B。

• 线程A从0循环1000次加1，sum已经累加到500了。
• 线程B突然出现，它算了一次，结果sum=0+1，sum变成了1。
• 线程A再读取，基数就变成了1，线程A已经循环500次了，它对sum是无感知的，还会继续累加500次。
• 如果线程B不再打扰线程A，那么结果就是501，如果线程B还会打扰，结果就难料了。
  

实际场景就是上述场景的疯狂版，多个线程，无序乱抢占，结果就是你的代码输出结果总在变，正常应该输出100000,200000,300000。
4）另外建议join()用上，然后循环方式建立多个线程：

1. if __name__ == '__main__':
   
2.     lock = Lock()
   
3.     t_l = []
   
4.     n = 10000
   
5.     for i in range(3):
   
6.         t = sum1(n)
   
7.         t_l.append(t)
   
8.         t.start()
   
9.     for t in t_l:
   
10.         t.join()

复制代码