Python中最常用的5种线程锁,你都会用吗

姿态人生

对于日常开发者来讲很少会使用到本章节的内容，但是对框架作者等是必备知识，同时也是高频的面试常见问题。
1.线程安全

线程安全是多线程或多进程编程中的一个概念，在拥有共享数据的多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行，不会出现数据污染等意外情况。
线程安全的问题最主要还是由线程切换导致的，比如一个房间（进程）中有10颗糖（资源），除此之外还有3个小人（1个主线程、2个子线程），当小人A吃了3颗糖后被系统强制进行休息时他认为还剩下7颗糖，而当小人B工作后又吃掉了3颗糖，那么当小人A重新上岗时会认为糖还剩下7颗，但是实际上只有4颗了。
上述例子中线程A和线程B的数据不同步，这就是线程安全问题，它可能导致非常严重的意外情况发生，我们按下面这个示例来进行说明。
下面有一个数值num初始值为0，我们开启2条线程：

• 线程1对num进行一千万次+1的操作
  
• 线程2对num进行一千万次-1的操作
  

结果可能会令人咋舌，num最后并不是我们所想象的结果0：

1. import threading
3. num = 0
6. def add():
7.     global num
8.     for i in range(10_000_000):
9.         num += 1
12. def sub():
13.     global num
14.     for i in range(10_000_000):
15.         num -= 1
18. if __name__ == "__main__":
19.     subThread01 = threading.Thread(target=add)
20.     subThread02 = threading.Thread(target=sub)
22.     subThread01.start()
23.     subThread02.start()
25.     subThread01.join()
26.     subThread02.join()
28.     print("num result : %s" % num)
30. # 结果三次采集
31. # num result : 669214
32. # num result : -1849179
33. # num result : -525674

复制代码

上面这就是一个非常好的案例，想要解决这个问题就必须通过锁来保障线程切换的时机。
需要我们值得留意的是，在Python基本数据类型中list、tuple、dict本身就是属于线程安全的，所以如果有多个线程对这3种容器做操作时，我们不必考虑线程安全问题。
2.锁的作用

锁是Python提供给我们能够自行操控线程切换的一种手段，使用锁可以让线程的切换变的有序。
一旦线程的切换变的有序后，各个线程之间对数据的访问、修改就变的可控，所以若要保证线程安全，就必须使用锁。
threading模块中提供了5种最常见的锁，下面是按照功能进行划分：

• 同步锁：lock（一次只能放行一个）
  
• 递归锁：rlock（一次只能放行一个）
  
• 条件锁：condition（一次可以放行任意个）
  
• 事件锁：event（一次全部放行）
  
• 信号量锁：semaphore（一次可以放行特定个）
  

3.Lock() 同步锁

基本介绍
Lock锁的称呼有很多，如：

• 同步锁
  
• 互斥锁
  

它们是什么意思呢？如下所示：

• 互斥指的是某一资源同一时刻仅能有一个访问者对其进行访问，具有唯一性和排他性，但是互斥无法限制访问者对资源的访问顺序，即访问是无序的
  
• 同步是指在互斥的基础上（大多数情况），通过其他机制实现访问者对资源的有序访问
  
• 同步其实已经实现了互斥，是互斥的一种更为复杂的实现，因为它在互斥的基础上实现了有序访问的特点
  

下面是threading模块与同步锁提供的相关方法：
方法描述threading.Lock()返回一个同步锁对象lockObject.acquire(blocking=True, timeout=1)上锁，当一个线程在执行被上锁代码块时，将不允许切换到其他线程运行，默认锁失效时间为1秒lockObject.release()解锁，当一个线程在执行未被上锁代码块时，将允许系统根据策略自行切换到其他线程中运行lockObject.locaked()判断该锁对象是否处于上锁状态，返回一个布尔值使用方式
同步锁一次只能放行一个线程，一个被加锁的线程在运行时不会将执行权交出去，只有当该线程被解锁时才会将执行权通过系统调度交由其他线程。
如下所示，使用同步锁解决最上面的问题：

1. import threading
3. num = 0
6. def add():
7.     lock.acquire()
8.     global num
9.     for i in range(10_000_000):
10.         num += 1
11.     lock.release()
14. def sub():
15.     lock.acquire()
16.     global num
17.     for i in range(10_000_000):
18.         num -= 1
19.     lock.release()
21. if __name__ == "__main__":
22.     lock = threading.Lock()
24.     subThread01 = threading.Thread(target=add)
25.     subThread02 = threading.Thread(target=sub)
27.     subThread01.start()
28.     subThread02.start()
30.     subThread01.join()
31.     subThread02.join()
33.     print("num result : %s" % num)
35. # 结果三次采集
36. # num result : 0
37. # num result : 0
38. # num result : 0

复制代码

这样这个代码就完全变成了串行的状态，对于这种计算密集型I/O业务来说，还不如直接使用串行化单线程执行来得快，所以这个例子仅作为一个示例，不能概述锁真正的用途。
死锁现象
对于同步锁来说，一次acquire()必须对应一次release()，不能出现连续重复使用多次acquire()后再重复使用多次release()的操作，这样会引起死锁造成程序的阻塞，完全不动了，如下所示：

1. import threading
3. num = 0
6. def add():
7.     lock.acquire()  # 上锁
8.     lock.acquire()  # 死锁
9.     # 不执行
10.     global num
11.     for i in range(10_000_000):
12.         num += 1
13.     lock.release()
14.     lock.release()
17. def sub():
18.     lock.acquire()  # 上锁
19.     lock.acquire()  # 死锁
20.     # 不执行
21.     global num
22.     for i in range(10_000_000):
23.         num -= 1
24.     lock.release()
25.     lock.release()
28. if __name__ == "__main__":
29.     lock = threading.Lock()
31.     subThread01 = threading.Thread(target=add)
32.     subThread02 = threading.Thread(target=sub)
34.     subThread01.start()
35.     subThread02.start()
37.     subThread01.join()
38.     subThread02.join()
40.     print("num result : %s" % num)

复制代码

with语句
由于threading.Lock()对象中实现了__enter__()与__exit__()方法，故我们可以使用with语句进行上下文管理形式的加锁解锁操作：

1. import threading
3. num = 0
6. def add():
7.     with lock:
8.         # 自动加锁
9.         global num
10.         for i in range(10_000_000):
11.             num += 1
12.         # 自动解锁
15. def sub():
16.     with lock:
17.         # 自动加锁
18.         global num
19.         for i in range(10_000_000):
20.             num -= 1
21.         # 自动解锁
24. if __name__ == "__main__":
25.     lock = threading.Lock()
27.     subThread01 = threading.Thread(target=add)
28.     subThread02 = threading.Thread(target=sub)
30.     subThread01.start()
31.     subThread02.start()
33.     subThread01.join()
34.     subThread02.join()
36.     print("num result : %s" % num)
37. #Python小白学习交流群：153708845   
38. # 结果三次采集
39. # num result : 0
40. # num result : 0
41. # num result : 0

复制代码

4.RLock() 递归锁

基本介绍
递归锁是同步锁的一个升级版本，在同步锁的基础上可以做到连续重复使用多次acquire()后再重复使用多次release()的操作，但是一定要注意加锁次数和解锁次数必须一致，否则也将引发死锁现象。
下面是threading模块与递归锁提供的相关方法：
方法描述threading.RLock()返回一个递归锁对象lockObject.acquire(blocking=True, timeout=1)上锁，当一个线程在执行被上锁代码块时，将不允许切换到其他线程运行，默认锁失效时间为1秒lockObject.release()解锁，当一个线程在执行未被上锁代码块时，将允许系统根据策略自行切换到其他线程中运行lockObject.locaked()判断该锁对象是否处于上锁状态，返回一个布尔值使用方式
以下是递归锁的简单使用，下面这段操作如果使用同步锁则会发生死锁现象，但是递归锁不会：

1. import threading
3. num = 0
6. def add():
7.     lock.acquire()
8.     lock.acquire()
9.     global num
10.     for i in range(10_000_000):
11.         num += 1
12.     lock.release()
13.     lock.release()
16. def sub():
17.     lock.acquire()
18.     lock.acquire()
19.     global num
20.     for i in range(10_000_000):
21.         num -= 1
22.     lock.release()
23.     lock.release()
26. if __name__ == "__main__":
27.     lock = threading.RLock()
29.     subThread01 = threading.Thread(target=add)
30.     subThread02 = threading.Thread(target=sub)
32.     subThread01.start()
33.     subThread02.start()
35.     subThread01.join()
36.     subThread02.join()
38.     print("num result : %s" % num)
40. # 结果三次采集
41. # num result : 0
42. # num result : 0
43. # num result : 0

复制代码

with语句
由于threading.RLock()对象中实现了__enter__()与__exit__()方法，故我们可以使用with语句进行上下文管理形式的加锁解锁操作：

1. import threading
3. num = 0
6. def add():
7.     with lock:
8.         # 自动加锁
9.         global num
10.         for i in range(10_000_000):
11.             num += 1
12.         # 自动解锁
15. def sub():
16.     with lock:
17.         # 自动加锁
18.         global num
19.         for i in range(10_000_000):
20.             num -= 1
21.         # 自动解锁
24. if __name__ == "__main__":
25.     lock = threading.RLock()
27.     subThread01 = threading.Thread(target=add)
28.     subThread02 = threading.Thread(target=sub)
30.     subThread01.start()
31.     subThread02.start()
33.     subThread01.join()
34.     subThread02.join()
36.     print("num result : %s" % num)
38. # 结果三次采集
39. # num result : 0
40. # num result : 0
41. # num result : 0

复制代码

5.Condition() 条件锁

基本介绍
条件锁是在递归锁的基础上增加了能够暂停线程运行的功能。并且我们可以使用wait()与notify()来控制线程执行的个数。
注意：条件锁可以自由设定一次放行几个线程。
下面是threading模块与条件锁提供的相关方法：
方法描述threading.Condition()返回一个条件锁对象lockObject.acquire(blocking=True, timeout=1)上锁，当一个线程在执行被上锁代码块时，将不允许切换到其他线程运行，默认锁失效时间为1秒lockObject.release()解锁，当一个线程在执行未被上锁代码块时，将允许系统根据策略自行切换到其他线程中运行lockObject.wait(timeout=None)将当前线程设置为“等待”状态，只有该线程接到“通知”或者超时时间到期之后才会继续运行，在“等待”状态下的线程将允许系统根据策略自行切换到其他线程中运行lockObject.wait_for(predicate, timeout=None)将当前线程设置为“等待”状态，只有该线程的predicate返回一个True或者超时时间到期之后才会继续运行，在“等待”状态下的线程将允许系统根据策略自行切换到其他线程中运行。注意：predicate参数应当传入一个可调用对象，且返回结果为bool类型lockObject.notify(n=1)通知一个当前状态为“等待”的线程继续运行，也可以通过参数n通知多个lockObject.notify_all()通知所有当前状态为“等待”的线程继续运行使用方式
下面这个案例会启动10个子线程，并且会立即将10个子线程设置为等待状态。
然后我们可以发送一个或者多个通知，来恢复被等待的子线程继续运行：

1. import threading
3. currentRunThreadNumber = 0
4. maxSubThreadNumber = 10
7. def task():
8.     global currentRunThreadNumber
9.     thName = threading.currentThread().name
11.     condLock.acquire()  # 上锁
12.     print("start and wait run thread : %s" % thName)
14.     condLock.wait()  # 暂停线程运行、等待唤醒
15.     currentRunThreadNumber += 1
16.     print("carry on run thread : %s" % thName)
18.     condLock.release()  # 解锁
21. if __name__ == "__main__":
22.     condLock = threading.Condition()
24.     for i in range(maxSubThreadNumber):
25.         subThreadIns = threading.Thread(target=task)
26.         subThreadIns.start()
28.     while currentRunThreadNumber < maxSubThreadNumber:
29.         notifyNumber = int(
30.             input("Please enter the number of threads that need to be notified to run："))
32.         condLock.acquire()
33.         condLock.notify(notifyNumber)  # 放行
34.         condLock.release()
36.     print("main thread run end")
37.    
38. # 先启动10个子线程，然后这些子线程会全部变为等待状态
39. # start and wait run thread : Thread-1
40. # start and wait run thread : Thread-2
41. # start and wait run thread : Thread-3
42. # start and wait run thread : Thread-4
43. # start and wait run thread : Thread-5
44. # start and wait run thread : Thread-6
45. # start and wait run thread : Thread-7
46. # start and wait run thread : Thread-8
47. # start and wait run thread : Thread-9
48. # start and wait run thread : Thread-10
50. # 批量发送通知，放行特定数量的子线程继续运行
51. # Please enter the number of threads that need to be notified to run：5  # 放行5个
52. # carry on run thread : Thread-4
53. # carry on run thread : Thread-3
54. # carry on run thread : Thread-1
55. # carry on run thread : Thread-2
56. # carry on run thread : Thread-5
58. # Please enter the number of threads that need to be notified to run：5  # 放行5个
59. # carry on run thread : Thread-8
60. # carry on run thread : Thread-10
61. # carry on run thread : Thread-6
62. # carry on run thread : Thread-9
63. # carry on run thread : Thread-7
65. # Please enter the number of threads that need to be notified to run：1
66. # main thread run end

复制代码

with语句
由于threading.Condition()对象中实现了__enter__()与__exit__()方法，故我们可以使用with语句进行上下文管理形式的加锁解锁操作：

1. import threading
3. currentRunThreadNumber = 0
4. maxSubThreadNumber = 10
7. def task():
8.     global currentRunThreadNumber
9.     thName = threading.currentThread().name
11.     with condLock:
12.         print("start and wait run thread : %s" % thName)
13.         condLock.wait()  # 暂停线程运行、等待唤醒
14.         currentRunThreadNumber += 1
15.         print("carry on run thread : %s" % thName)
18. if __name__ == "__main__":
19.     condLock = threading.Condition()
21.     for i in range(maxSubThreadNumber):
22.         subThreadIns = threading.Thread(target=task)
23.         subThreadIns.start()
25.     while currentRunThreadNumber < maxSubThreadNumber:
26.         notifyNumber = int(
27.             input("Please enter the number of threads that need to be notified to run："))
29.         with condLock:
30.             condLock.notify(notifyNumber)  # 放行
32.     print("main thread run end")

复制代码

6.Event() 事件锁

基本介绍
事件锁是基于条件锁来做的，它与条件锁的区别在于一次只能放行全部，不能放行任意个数量的子线程继续运行。
我们可以将事件锁看为红绿灯，当红灯时所有子线程都暂停运行，并进入“等待”状态，当绿灯时所有子线程都恢复“运行”。
下面是threading模块与事件锁提供的相关方法：
方法描述threading.Event()返回一个事件锁对象lockObject.clear()将事件锁设为红灯状态，即所有线程暂停运行lockObject.is_set()用来判断当前事件锁状态，红灯为False，绿灯为TruelockObject.set()将事件锁设为绿灯状态，即所有线程恢复运行lockObject.wait(timeout=None)将当前线程设置为“等待”状态，只有该线程接到“绿灯通知”或者超时时间到期之后才会继续运行，在“等待”状态下的线程将允许系统根据策略自行切换到其他线程中运行使用方式
事件锁不能利用with语句来进行使用，只能按照常规方式。
如下所示，我们来模拟线程和红绿灯的操作，红灯停，绿灯行：

1. import threading
3. maxSubThreadNumber = 3
6. def task():
7.     thName = threading.currentThread().name
8.     print("start and wait run thread : %s" % thName)
9.     eventLock.wait()  # 暂停运行，等待绿灯
10.     print("green light, %s carry on run" % thName)
11.     print("red light, %s stop run" % thName)
12.     eventLock.wait()  # 暂停运行，等待绿灯
13.     print("green light, %s carry on run" % thName)
14.     print("sub thread %s run end" % thName)
17. if __name__ == "__main__":
19.     eventLock = threading.Event()
21.     for i in range(maxSubThreadNumber):
22.         subThreadIns = threading.Thread(target=task)
23.         subThreadIns.start()
25.     eventLock.set()  # 设置为绿灯
26.     eventLock.clear()  # 设置为红灯
27.     eventLock.set()  # 设置为绿灯
29. # start and wait run thread : Thread-1
30. # start and wait run thread : Thread-2
31. # start and wait run thread : Thread-3
33. # green light, Thread-1 carry on run
34. # red light, Thread-1 stop run
35. # green light, Thread-1 carry on run
36. # sub thread Thread-1 run end
38. # green light, Thread-3 carry on run
39. # red light, Thread-3 stop run
40. # green light, Thread-3 carry on run
41. # sub thread Thread-3 run end
43. # green light, Thread-2 carry on run
44. # red light, Thread-2 stop run
45. # green light, Thread-2 carry on run
46. # sub thread Thread-2 run end

复制代码

7.Semaphore() 信号量锁

基本介绍
信号量锁也是根据条件锁来做的，它与条件锁和事件锁的区别如下：

• 条件锁：一次可以放行任意个处于“等待”状态的线程
  
• 事件锁：一次可以放行全部的处于“等待”状态的线程
  
• 信号量锁：通过规定，成批的放行特定个处于“上锁”状态的线程
  

下面是threading模块与信号量锁提供的相关方法：
方法描述threading.Semaphore()返回一个信号量锁对象lockObject.acquire(blocking=True, timeout=1)上锁，当一个线程在执行被上锁代码块时，将不允许切换到其他线程运行，默认锁失效时间为1秒lockObject.release()解锁，当一个线程在执行未被上锁代码块时，将允许系统根据策略自行切换到其他线程中运行使用方式
以下是使用示例，你可以将它当做一段限宽的路段，每次只能放行相同数量的线程：

1. import threading
2. import time
4. maxSubThreadNumber = 6
7. def task():
8.     thName = threading.currentThread().name
9.     semaLock.acquire()
10.     print("run sub thread %s" % thName)
11.     time.sleep(3)
12.     semaLock.release()
15. if __name__ == "__main__":
16.     # 每次只能放行2个
17.     semaLock = threading.Semaphore(2)
19.     for i in range(maxSubThreadNumber):
20.         subThreadIns = threading.Thread(target=task)
21.         subThreadIns.start()
24. # run sub thread Thread-1
25. # run sub thread Thread-2
27. # run sub thread Thread-3
28. # run sub thread Thread-4
30. # run sub thread Thread-6
31. # run sub thread Thread-5

复制代码

with语句
由于threading.Semaphore()对象中实现了__enter__()与__exit__()方法，故我们可以使用with语句进行上下文管理形式的加锁解锁操作：

1. import threading
2. import time
4. maxSubThreadNumber = 6
7. def task():
8.     thName = threading.currentThread().name
9.     with semaLock:
10.         print("run sub thread %s" % thName)
11.         time.sleep(3)
14. if __name__ == "__main__":
16.     semaLock = threading.Semaphore(2)
18.     for i in range(maxSubThreadNumber):
19.         subThreadIns = threading.Thread(target=task)
20.         subThreadIns.start()

复制代码

8.锁关系浅析

上面5种锁可以说都是基于同步锁来做的，这些你都可以从源码中找到答案。
首先来看RLock递归锁，递归锁的实现非常简单，它的内部会维护着一个计数器，当计数器不为0的时候该线程不能被I/O操作和时间轮询机制切换。但是当计数器为0的时候便不会如此了：

1. def __init__(self):
2.     self._block = _allocate_lock()
3.     self._owner = None
4.     self._count = 0  # 计数器

复制代码

而Condition条件锁的内部其实是有两把锁的，一把底层锁（同步锁）一把高级锁(递归锁)。
低层锁的解锁方式有两种，使用wait()方法会暂时解开底层锁同时加上一把高级锁，只有当接收到别的线程里的notfiy()后才会解开高级锁和重新上锁低层锁，也就是说条件锁底层是根据同步锁和递归锁的不断切换来进行实现的：

1. def __init__(self, lock=None):
2.     if lock is None:
3.         lock = RLock()  # 可以看到条件锁的内部是基于递归锁，而递归锁又是基于同步锁来做的
4.     self._lock = lock
6.     self.acquire = lock.acquire
7.     self.release = lock.release
8.     try:
9.         self._release_save = lock._release_save
10.     except AttributeError:
11.         pass
12.     try:
13.         self._acquire_restore = lock._acquire_restore
14.     except AttributeError:
15.         pass
16.     try:
17.         self._is_owned = lock._is_owned
18.     except AttributeError:
19.         pass
20.     self._waiters = _deque()

复制代码

Event事件锁内部是基于条件锁来做的：

1. class Event:
3.     def __init__(self):
4.         self._cond = Condition(Lock())  # 实例化出了一个条件锁。
5.         self._flag = False
7.     def _reset_internal_locks(self):
8.         # private!  called by Thread._reset_internal_locks by _after_fork()
9.         self._cond.__init__(Lock())
11.     def is_set(self):
12.         """Return true if and only if the internal flag is true."""
13.         return self._flag
15.     isSet = is_set

复制代码

Semaphore信号量锁内部也是基于条件锁来做的：

1. class Semaphore:
3.     def __init__(self, value=1):
4.         if value < 0:
5.             raise ValueError("semaphore initial value must be >= 0")
6.         self._cond = Condition(Lock()) # 可以看到，这里是实例化出了一个条件锁
7.         self._value = value

复制代码

9.基本练习题

条件锁的应用
需求：一个空列表，两个线程轮番往里面加值（一个加偶数，一个加奇数），最终让该列表中的值为 1 - 100 ，且是有序排列的。

1. import threading
3. lst = []
6. def even():
7.     """加偶数"""
8.     with condLock:
9.         for i in range(2, 101, 2):
10.             # 判断当前列表的长度处于2是否能处尽
11.             # 如果能处尽则代表需要添加奇数
12.             # 否则就添加偶数
13.             if len(lst) % 2 != 0:
14.                 # 添偶数
15.                 lst.append(i)      # 先添加值
16.                 condLock.notify()  # 告诉另一个线程，你可以加奇数了，但是这里不会立即交出执行权
17.                 condLock.wait()    # 交出执行权，并等待另一个线程通知加偶数
18.             else:
19.                 # 添奇数
20.                 condLock.wait()  # 交出执行权，等待另一个线程通知加偶数
21.                 lst.append(i)   
22.                 condLock.notify()
23.         condLock.notify()
26. def odd():
27.     """加奇数"""
28.     with condLock:
29.         for i in range(1, 101, 2):
30.             if len(lst) % 2 == 0:
31.                 lst.append(i)
32.                 condLock.notify()
33.                 condLock.wait()
34.         condLock.notify()
37. if __name__ == "__main__":
38.     condLock = threading.Condition()
40.     addEvenTask = threading.Thread(target=even)
41.     addOddTask = threading.Thread(target=odd)
43.     addEvenTask.start()
44.     addOddTask.start()
46.     addEvenTask.join()
47.     addOddTask.join()
49.     print(lst)

复制代码

事件锁的应用
有2个任务线程来扮演李白和杜甫，如何让他们一人一句进行对答？文本如下：

1. 杜甫：老李啊，来喝酒！
3. 李白：老杜啊，不喝了我喝不下了！
5. 杜甫：老李啊，再来一壶？
7. 杜甫：...老李？
9. 李白：呼呼呼...睡着了..

复制代码

代码如下：

1. import threading
3. #Python小白学习交流群：153708845
4. def libai():
5.     event.wait()  
6.     print("李白：老杜啊，不喝了我喝不下了！")
7.     event.set()
8.     event.clear()
9.     event.wait()
10.     print("李白：呼呼呼...睡着了..")
12. def dufu():
13.     print("杜甫：老李啊，来喝酒！")
14.     event.set()  
15.     event.clear()
16.     event.wait()
17.     print("杜甫：老李啊，再来一壶？")
18.     print("杜甫：...老李？")
19.     event.set()
22. if __name__ == '__main__':
24.     event = threading.Event()
26.     t1 = threading.Thread(target=libai)
27.     t2 = threading.Thread(target=dufu)
29.     t1.start()
30.     t2.start()
31.     t1.join()
32.     t2.join()

复制代码

来源:https://www.cnblogs.com/python1111/p/17794249.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！