多个线程锁

新学

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

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. """
    

复制代码