Python中最常用的五种线程锁，你会用吗？，

文章由Byrx.net分享于2021-09-17 09:09:06评论（610）

Python中最常用的五种线程锁，你会用吗？，


 

前言

本文将继续围绕 threading 模块讲解，基本上是纯理论偏多。

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

官方文档(https://docs.python.org/zh-cn/3.6/library/threading.html)

线程安全

线程安全是多线程或多进程编程中的一个概念，在拥有共享数据的多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行，不会出现数据污染等意外情况。

线程安全的问题最主要还是由线程切换导致的，比如一个房间（进程）中有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  
  2. num = 0  
  3. def add():  
  4.     global num  
  5.     for i in range(10_000_000):  
  6.         num += 1  
  7. def sub():  
  8.     global num  
  9.     for i in range(10_000_000):  
  10.         num -= 1  
  11. if __name__ == "__main__":  
  12.     subThread01 = threading.Thread(target=add)  
  13.     subThread02 = threading.Thread(target=sub)  
  14.     subThread01.start()  
  15.     subThread02.start()  
  16.     subThread01.join()  
  17.     subThread02.join()  
  18.     print("num result : %s" % num)  
  19. # 结果三次采集  
  20. # num result : 669214  
  21. # num result : -1849179  
  22. # num result : -525674 

上面这就是一个非常好的案例，想要解决这个问题就必须通过锁来保障线程切换的时机。

需要我们值得留意的是，在Python基本数据类型中list、tuple、dict本身就是属于线程安全的，所以如果有多个线程对这3种容器做操作时，我们不必考虑线程安全问题。

锁的作用

锁是Python提供给我们能够自行操控线程切换的一种手段，使用锁可以让线程的切换变的有序。

一旦线程的切换变的有序后，各个线程之间对数据的访问、修改就变的可控，所以若要保证线程安全，就必须使用锁。

threading模块中提供了5种最常见的锁，下面是按照功能进行划分：

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

1、Lock() 同步锁

基本介绍

Lock锁的称呼有很多，如：

  •  同步锁
  •  互斥锁

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

下面是threading模块与同步锁提供的相关方法：

方法 描述
threading.Lock() 返回一个同步锁对象
lockObject.acquire(blocking=True, timeout=1) 上锁，当一个线程在执行被上锁代码块时，将不允许切换到其他线程运行，默认锁失效时间为1秒
lockObject.release() 解锁，当一个线程在执行未被上锁代码块时，将允许系统根据策略自行切换到其他线程中运行
lockObject.locaked() 判断该锁对象是否处于上锁状态，返回一个布尔值

使用方式

同步锁一次只能放行一个线程，一个被加锁的线程在运行时不会将执行权交出去，只有当该线程被解锁时才会将执行权通过系统调度交由其他线程。

如下所示，使用同步锁解决最上面的问题：

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

这样这个代码就完全变成了串行的状态，对于这种计算密集型I/O业务来说，还不如直接使用串行化单线程执行来得快，所以这个例子仅作为一个示例，不能概述锁真正的用途。

死锁现象

对于同步锁来说，一次acquire()必须对应一次release()，不能出现连续重复使用多次acquire()后再重复使用多次release()的操作，这样会引起死锁造成程序的阻塞，完全不动了，如下所示：

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

with语句

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

  1. import threading  
  2. num = 0  
  3. def add():  
  4.     with lock:  
  5.         # 自动加锁  
  6.         global num  
  7.         for i in range(10_000_000):  
  8.             num += 1  
  9.         # 自动解锁  
  10. def sub():  
  11.     with lock:  
  12.         # 自动加锁  
  13.         global num  
  14.         for i in range(10_000_000):  
  15.             num -= 1  
  16.         # 自动解锁  
  17. if __name__ == "__main__":  
  18.     lock = threading.Lock()  
  19.     subThread01 = threading.Thread(target=add)  
  20.     subThread02 = threading.Thread(target=sub)  
  21.     subThread01.start()  
  22.     subThread02.start() 
  23.     subThread01.join()  
  24.     subThread02.join()  
  25.     print("num result : %s" % num) 
  26.  # 结果三次采集  
  27. # num result : 0  
  28. # num result : 0  
  29. # num result : 0 

2、RLock() 递归锁

基本介绍

递归锁是同步锁的一个升级版本，在同步锁的基础上可以做到连续重复使用多次acquire()后再重复使用多次release()的操作，但是一定要注意加锁次数和解锁次数必须一致，否则也将引发死锁现象。

下面是threading模块与递归锁提供的相关方法：

方法 描述
threading.RLock() 返回一个递归锁对象
lockObject.acquire(blocking=True, timeout=1) 上锁，当一个线程在执行被上锁代码块时，将不允许切换到其他线程运行，默认锁失效时间为1秒
lockObject.release() 解锁，当一个线程在执行未被上锁代码块时，将允许系统根据策略自行切换到其他线程中运行
lockObject.locaked() 判断该锁对象是否处于上锁状态，返回一个布尔值

使用方式

以下是递归锁的简单使用，下面这段操作如果使用同步锁则会发生死锁现象，但是递归锁不会：

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

with语句

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

  1. import threading  
  2. num = 0  
  3. def add():  
  4.     with lock:  
  5.         # 自动加锁  
  6.         global num  
  7.         for i in range(10_000_000):  
  8.             num += 1  
  9.         # 自动解锁  
  10. def sub():  
  11.     with lock:  
  12.         # 自动加锁  
  13.         global num  
  14.         for i in range(10_000_000):  
  15.             num -= 1  
  16.         # 自动解锁  
  17. if __name__ == "__main__":  
  18.     lock = threading.RLock()  
  19.     subThread01 = threading.Thread(target=add)  
  20.     subThread02 = threading.Thread(target=sub)  
  21.     subThread01.start()  
  22.     subThread02.start()  
  23.     subThread01.join()  
  24.     subThread02.join()  
  25.     print("num result : %s" % num) 
  26. # 结果三次采集  
  27. # num result : 0  
  28. # num result : 0  
  29. # num result : 0 

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

with语句

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

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

4、Event() 事件锁

基本介绍

事件锁是基于条件锁来做的，它与条件锁的区别在于一次只能放行全部，不能放行任意个数量的子线程继续运行。

我们可以将事件锁看为红绿灯，当红灯时所有子线程都暂停运行，并进入“等待”状态，当绿灯时所有子线程都恢复“运行”。

下面是threading模块与事件锁提供的相关方法：

方法 描述
threading.Event() 返回一个事件锁对象
lockObject.clear() 将事件锁设为红灯状态，即所有线程暂停运行
lockObject.is_set() 用来判断当前事件锁状态，红灯为False，绿灯为True
lockObject.set() 将事件锁设为绿灯状态，即所有线程恢复运行
lockObject.wait(timeout=None) 将当前线程设置为“等待”状态，只有该线程接到“绿灯通知”或者超时时间到期之后才会继续运行，在“等待”状态下的线程将允许系统根据策略自行切换到其他线程中运行

使用方式

事件锁不能利用with语句来进行使用，只能按照常规方式。

如下所示，我们来模拟线程和红绿灯的操作，红灯停，绿灯行：

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

5、Semaphore() 信号量锁

基本介绍

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

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

下面是threading模块与信号量锁提供的相关方法：

方法 描述
threading.Semaphore() 返回一个信号量锁对象
lockObject.acquire(blocking=True, timeout=1) 上锁，当一个线程在执行被上锁代码块时，将不允许切换到其他线程运行，默认锁失效时间为1秒
lockObject.release() 解锁，当一个线程在执行未被上锁代码块时，将允许系统根据策略自行切换到其他线程中运行

使用方式

以下是使用示例，你可以将它当做一段限宽的路段，每次只能放行相同数量的线程：

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

with语句

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

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

锁关系浅析

上面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  
  5.     self.acquire = lock.acquire  
  6.     self.release = lock.release  
  7.     try:  
  8.         self._release_save = lock._release_save  
  9.     except AttributeError:  
  10.         pass  
  11.     try:  
  12.         self._acquire_restore = lock._acquire_restore  
  13.     except AttributeError:  
  14.         pass  
  15.     try:  
  16.         self._is_owned = lock._is_owned  
  17.     except AttributeError:  
  18.         pass  
  19.     self._waiters = _deque() 

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

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

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

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

基本练习题

条件锁的应用

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

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

事件锁的应用

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

杜甫：老李啊，来喝酒！

李白：老杜啊，不喝了我喝不下了！

杜甫：老李啊，再来一壶？

杜甫：...老李？

李白：呼呼呼...睡着了..

代码如下：

  1. import threading  
  2. def libai():  
  3.     event.wait()    
  4.     print("李白：老杜啊，不喝了我喝不下了！")  
  5.     event.set()  
  6.     event.clear()  
  7.     event.wait()  
  8.     print("李白：呼呼呼...睡着了..")  
  9. def dufu():  
  10.     print("杜甫：老李啊，来喝酒！")  
  11.     event.set()    
  12.     event.clear()  
  13.     event.wait() 
  14.     print("杜甫：老李啊，再来一壶？")  
  15.     print("杜甫：...老李？")  
  16.     event.set()  
  17. if __name__ == '__main__':  
  18.     event = threading.Event()  
  19.     t1 = threading.Thread(target=libai)  
  20.     t2 = threading.Thread(target=dufu)  
  21.     t1.start()  
  22.     t2.start()  
  23.     t1.join()  
  24.     t2.join()  

相关内容

评论关闭

最新python教程

python~HOT