在开发过程中如果使用了多线程，就应该关注线程安全的问题，尤其是多个线程共同操作的数据。

本文通过以下示例， 详细讲解如何通过 threading.Lock 和threading.RLock来保证线程的安全。

以下是一个数字相加的案例， count 是一个全局变量，通过 add_num 函数来执行相加，函数接收两个参数，一个线程名字， 另一个是相加次数。在相加的过程中，模拟需要处理的时间，使线程 sleep0.01 秒。两个线程同时启动，并等待两个线程都执行完打印 count 的值。

import time
from threading import Thread

count = 0

# 实现对count相加
def add_num(times: int, t_name: str):
    global count

    for i in range(times):
        c = count
        time.sleep(0.01)
        print(f"{t_name}=>{count}")
        count = c + 1

if __name__ == '__main__':
    # 启动线程t1和t2
    t1 = Thread(target=add_num, args=(200, 't1'))
    t2 = Thread(target=add_num, args=(300, 't2'))

    t1.start()
    t2.start()

    t1.join()
    t2.join()

    print(count)

以下是截取了运行过程中打印的日志（实际运行时每次出现的情况不一定相同），

从图中可以看到，首先一点是在执行的过程中，数据出现了混乱，当 t2=46 的时候, t1 也是 46， 同时 t2 出现了两次 46 的情况，再者就是结果输出为 300，按照实际的想法两个线程分别执行 add_num 函数，最后结果应该是 500 才对。当出现上述问题的时候， 我们就可以说，add_num 函数是线程不安全的。

同步锁 Lock

为了解决这个问题，Python提供了 threading 模块 Lock 类来实现线程加锁， 使 add_num 函数变成线程安全的。

Lock 中有两个方法，用来表示加锁和释放锁：

1. acquire(blocking=True, timeout=-1): 其中 blocking 表示是否阻塞线程, 默认为 True, 表示锁不可用时, 线程会被阻塞, 直到锁可用。如果为 False 时，表示当锁不可用是， 该方法会直接返回结果， 表示获取锁失败。 timeout 参数表示等待获取锁的时长，默认为-1，一直等待锁，设置超时时间后，等待超时后会直接返回 False 表示获取锁失败。
2. release()： 无参数， 用来释放锁

以下是加锁后的代码：

import time
from threading import Thread, Lock

# 获取Lock实例
threadLock = Lock()
count = 0

def add_num(times: int, t_name: str):
    # 设置锁
    # 此时，当程序执行到此处时，需要获取锁
    # 否则会一直等待
    threadLock.acquire()
    global count
    try:
        for i in range(times):
            c = count
            time.sleep(0.01)
            print(f"{t_name}=>{count}")
            count = c + 1
    finally:
        # 将释放锁放到finally中
        # 是为了保证始终能释放锁
        threadLock.release()
        pass

if __name__ == '__main__':
    t1 = Thread(target=add_num, args=(200, 't1'))
    t2 = Thread(target=add_num, args=(300, 't2'))

    t1.start()
    t2.start()

    t1.join()
    t2.join()

    print(count)

执行结果如下图

从图中可以看到，两个线程按顺序执行，且结果是 500，符合预期。在程序中使用 Lock 加锁后，当其中一个线程获取到锁后，另一个线程必须等待锁释放才能继续执行逻辑。这就保证了多个线程不会同时修改数据导致数据混乱。

可重入锁 RLock

Python 中还提供了另一个锁对象 RLock，也可以实现线程互斥访问，其与 Lock 最大的不同是， RLock 允许同一线程多次获取同一个锁，而不会产生死锁。（如果一个线程已经获得了某个锁，那么在该线程没有释放锁之前，其他线程是无法获得该锁的。这种情况下，如果该线程在持有锁的状态下需要再次获得该锁，通常会出现死锁的问题）

RLock 和 Lock 的使用方式基本一致，都是通过acquire 和release 两个方法来加锁和释放锁的。

以下代码我们使用 Lock 加锁，在类 NumCounter 中increment 和decrement 两个方法都做了加锁处理，但是在 increment 中调用 decrement 时，前一个锁还未释放，因此，此段使用 Lock 加锁的代码就会因为等待锁而卡死。

import threading

class NumCounter:
    def __init__(self):
    # 初始化锁
        self.lock = threading.Lock()
        self.num = 0
	
	# increment 加锁
    def increment(self):
        with self.lock:
            self.num += 1
            self.decrement()

# decrement 加锁
    def decrement(self):
        with self.lock:
            self.num -= 1

c = NumCounter()

for i in range(10):
    t = threading.Thread(target=c.increment)
    t.start()

print(c.num)

执行上段代码就会发现程序会一直处于卡死状态。

解决这个问题，非常简单，只须将上述代码中 Lock 修改为 RLock（self.lock = threading.RLock()）， 程序就不会出现死锁的情况，正常运行。

#挑战30天在头条写日记#