python多线程系列—Lock锁(三)

一、线程安全概念

1、一个进程中可以有多个线程，且线程共享所有进程中的资源
2、多个线程同时操作一个东西，可能会导致数据混乱的情况
3、线程安全是指某个函数，函数库在多线程环境中被调用时，能够正确地处理多个线程之间的共享变量，使程序正确完成
由于线程的执行随时会发生切换，造成了不可预料的结果，出现线程不安全。

二、线程安全解决方案

1、使用线程锁Lock解决线程安全问题
2、线程锁释放的两种情况：等待(IO)导致python解释器锁释放，线程执行时长达到指定的阈值0.005秒
3、Lock与RLock都是锁
1、RLock是递归锁，支持锁多次【推荐使用】
2、Lock锁多次就会出现死锁，程序会卡死
4、死锁
1、两个程序同时竞争获取同一个锁

三、Lock使用语法

import threading
lock = threading.Lock()
lock.acquire()
try:
    #do  something
finally:
     lock.release()
     
lock = threading.Lock()
with lock:
      #do something
1
2
3
4
5
6
7
8
9
10
11

四、代码演示

场景：多线程提现
1、没有线程锁提现

import time
import threading

class Demo:
    def __init__(self,balance):
        self.balance = balance

    def withdraw(self,amount):
        if self.balance >=amount:
            # 等待一秒，账户余额为负数
            time.sleep(1)
            self.balance -= amount
            print("提现成功")
            print("账户余额:",self.balance)
        else:
            print("提现失败，余额不足")

if __name__ == '__main__':
    cl = Demo(balance=1000)
    th1 = threading.Thread(target=cl.withdraw,args=(600,))
    th2 = threading.Thread(target=cl.withdraw,args=(600,))
    th1.start()
    th2.start()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

输出：
提现成功
账户余额: 400
提现成功
账户余额: -200

2、有线程锁提现

import time
import threading

class Demo:
    def __init__(self,balance):
        self.balance = balance
        self.lock = threading.Lock()

    def withdraw(self,amount):
        #线程锁
        with self.lock:
            if self.balance >=amount:
                # time.sleep(1)
                self.balance -= amount
                print("提现成功")
                print("账户余额:",self.balance)
            else:
                print("提现失败，余额不足")

if __name__ == '__main__':
    cl = Demo(balance=1000)
    th1 = threading.Thread(target=cl.withdraw,args=(600,))
    th2 = threading.Thread(target=cl.withdraw,args=(600,))
    th1.start()
    th2.start()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25