多个线程锁

新学

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

from threading import Thread, Lock, enumerate

# 共用一把锁
lock = Lock()
class Sum1(Thread):
    sum = 0
    def __init__(self, n):
        super().__init__()
        self.n = n

    def run(self):
        for i in range(self.n):
            lock.acquire()  # 上锁，上锁后禁止cpu切换线程
            Sum1.sum += 1
            lock.release()  # 开锁，允许cpu切换线程
        print(Sum1.sum)


# 多个锁：每个对象都用自己的锁
class Sum2(Thread):
    sum = 0
    def __init__(self, n):
        super().__init__()
        self.n = n

    def run(self):
        lock1 = Lock()  # 用自己的锁
        for i in range(self.n):
            lock1.acquire()  # 上锁，上锁后禁止cpu切换线程
            Sum2.sum += 1
            lock1.release()  # 开锁，允许cpu切换线程
        print(Sum2.sum)

def main():
    n = 100000

    t1 = Sum1(n)  # Sum1公用一把锁
    t2 = Sum1(n)
    t3 = Sum1(n)

    # t1 = Sum2(n) # Sum2对象用自己的锁
    # t2 = Sum2(n)
    # t3 = Sum2(n)

    t1.start()
    t2.start()
    t3.start()


if __name__ == '__main__':
    main()


"""
运行结果：
共用一把锁时：
261921
285610
300000
多把锁时： # 随机的数据 线程在被锁住的地方切换了
194130 
199063
225863
"""

suchocolate

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

    def run(self):
        lock.acquire()  # 上锁，上锁后禁止其他线程访问
        for item in range(self.n):
            sum1.sum += 1
        print(sum1.sum)
        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()用上，然后循环方式建立多个线程：

if __name__ == '__main__':
    lock = Lock()
    t_l = []
    n = 10000
    for i in range(3):
        t = sum1(n)
        t_l.append(t)
        t.start()
    for t in t_l:
        t.join()