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

时间：2022-11-05 21:09:20

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. importthreading
  2. num=0
  3. defadd():
  4. globalnum
  5. foriinrange(10_000_000):
  6. num+=1
  7. defsub():
  8. globalnum
  9. foriinrange(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("numresult:%s"%num)
  19. #结果三次采集
  20. #numresult:669214
  21. #numresult:-1849179
  22. #numresult:-525674

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

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

锁的作用

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

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

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

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

1、Lock() 同步锁

基本介绍

Lock锁的称呼有很多，如：

  • 同步锁
  • 互斥锁

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

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

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

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

使用方式

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

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

  1. importthreading
  2. num=0
  3. defadd():
  4. lock.acquire()
  5. globalnum
  6. foriinrange(10_000_000):
  7. num+=1
  8. lock.release()defsub():
  9. lock.acquire()
  10. globalnum
  11. foriinrange(10_000_000):
  12. num-=1
  13. lock.release()
  14. if__name__=="__main__":
  15. lock=threading.Lock()
  16. subThread01=threading.Thread(target=add)
  17. subThread02=threading.Thread(target=sub)
  18. subThread01.start()
  19. subThread02.start()
  20. subThread01.join()
  21. subThread02.join()
  22. print("numresult:%s"%num)
  23. #结果三次采集
  24. #numresult:0
  25. #numresult:0
  26. #numresult:0

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

死锁现象

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

  1. importthreading
  2. num=0
  3. defadd():
  4. lock.acquire()#上锁
  5. lock.acquire()#死锁
  6. #不执行
  7. globalnum
  8. foriinrange(10_000_000):
  9. num+=1
  10. lock.release()
  11. lock.release()
  12. defsub():
  13. lock.acquire()#上锁
  14. lock.acquire()#死锁
  15. #不执行
  16. globalnum
  17. foriinrange(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("numresult:%s"%num)

with语句

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

  1. importthreading
  2. num=0
  3. defadd():
  4. withlock:
  5. #自动加锁
  6. globalnum
  7. foriinrange(10_000_000):
  8. num+=1
  9. #自动解锁
  10. defsub():
  11. withlock:
  12. #自动加锁
  13. globalnum
  14. foriinrange(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("numresult:%s"%num)
  26. #结果三次采集
  27. #numresult:0
  28. #numresult:0
  29. #numresult:0

2、RLock() 递归锁

基本介绍

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

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

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

使用方式

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

  1. importthreading
  2. num=0
  3. defadd():
  4. lock.acquire()
  5. lock.acquire()
  6. globalnum
  7. foriinrange(10_000_000):
  8. num+=1
  9. lock.release()
  10. lock.release()
  11. defsub():
  12. lock.acquire()
  13. lock.acquire()
  14. globalnum
  15. foriinrange(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("numresult:%s"%num)
  28. #结果三次采集
  29. #numresult:0
  30. #numresult:0
  31. #numresult:0

with语句

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

  1. importthreading
  2. num=0
  3. defadd():
  4. withlock:
  5. #自动加锁
  6. globalnum
  7. foriinrange(10_000_000):
  8. num+=1
  9. #自动解锁
  10. defsub():
  11. withlock:
  12. #自动加锁
  13. globalnum
  14. foriinrange(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("numresult:%s"%num)
  26. #结果三次采集
  27. #numresult:0
  28. #numresult:0
  29. #numresult: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. importthreading
  2. currentRunThreadNumber=0
  3. maxSubThreadNumber=10
  4. deftask():
  5. globalcurrentRunThreadNumber
  6. thName=threading.currentThread().name
  7. condLock.acquire()#上锁
  8. print("startandwaitrunthread:%s"%thName)
  9. condLock.wait()#暂停线程运行、等待唤醒
  10. currentRunThreadNumber+=1
  11. print("carryonrunthread:%s"%thName)
  12. condLock.release()#解锁
  13. if__name__=="__main__":
  14. condLock=threading.Condition()
  15. foriinrange(maxSubThreadNumber):
  16. subThreadIns=threading.Thread(target=task)
  17. subThreadIns.start()
  18. whilecurrentRunThreadNumber<maxSubThreadNumber:
  19. notifyNumber=int(
  20. input("Pleaseenterthenumberofthreadsthatneedtobenotifiedtorun："))
  21. condLock.acquire()
  22. condLock.notify(notifyNumber)#放行
  23. condLock.release()
  24. print("mainthreadrunend")
  25. #先启动10个子线程，然后这些子线程会全部变为等待状态
  26. #startandwaitrunthread:Thread-1
  27. #startandwaitrunthread:Thread-2
  28. #startandwaitrunthread:Thread-3
  29. #startandwaitrunthread:Thread-4
  30. #startandwaitrunthread:Thread-5
  31. #startandwaitrunthread:Thread-6
  32. #startandwaitrunthread:Thread-7
  33. #startandwaitrunthread:Thread-8
  34. #startandwaitrunthread:Thread-9
  35. #startandwaitrunthread:Thread-10
  36. #批量发送通知，放行特定数量的子线程继续运行
  37. #Pleaseenterthenumberofthreadsthatneedtobenotifiedtorun：5#放行5个
  38. #carryonrunthread:Thread-4
  39. #carryonrunthread:Thread-3
  40. #carryonrunthread:Thread-1
  41. #carryonrunthread:Thread-2
  42. #carryonrunthread:Thread-5
  43. #Pleaseenterthenumberofthreadsthatneedtobenotifiedtorun：5#放行5个
  44. #carryonrunthread:Thread-8
  45. #carryonrunthread:Thread-10
  46. #carryonrunthread:Thread-6
  47. #carryonrunthread:Thread-9
  48. #carryonrunthread:Thread-7
  49. #Pleaseenterthenumberofthreadsthatneedtobenotifiedtorun：1
  50. #mainthreadrunend

with语句

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

  1. importthreading
  2. currentRunThreadNumber=0
  3. maxSubThreadNumber=10
  4. deftask():
  5. globalcurrentRunThreadNumber
  6. thName=threading.currentThread().name
  7. withcondLock:
  8. print("startandwaitrunthread:%s"%thName)
  9. condLock.wait()#暂停线程运行、等待唤醒
  10. currentRunThreadNumber+=1
  11. print("carryonrunthread:%s"%thName)
  12. if__name__=="__main__":
  13. condLock=threading.Condition()
  14. foriinrange(maxSubThreadNumber):
  15. subThreadIns=threading.Thread(target=task)
  16. subThreadIns.start()
  17. whilecurrentRunThreadNumber<maxSubThreadNumber:
  18. notifyNumber=int(
  19. input("Pleaseenterthenumberofthreadsthatneedtobenotifiedtorun："))
  20. withcondLock:
  21. condLock.notify(notifyNumber)#放行
  22. print("mainthreadrunend")

4、Event() 事件锁

基本介绍

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

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

下面是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() 通知所有当前状态为“等待”的线程继续运行

使用方式

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

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

  1. importthreading
  2. maxSubThreadNumber=3
  3. deftask():
  4. thName=threading.currentThread().name
  5. print("startandwaitrunthread:%s"%thName)
  6. eventLock.wait()#暂停运行，等待绿灯
  7. print("greenlight,%scarryonrun"%thName)
  8. print("redlight,%sstoprun"%thName)
  9. eventLock.wait()#暂停运行，等待绿灯
  10. print("greenlight,%scarryonrun"%thName)
  11. print("subthread%srunend"%thName)
  12. if__name__=="__main__":
  13. eventLock=threading.Event()
  14. foriinrange(maxSubThreadNumber):
  15. subThreadIns=threading.Thread(target=task)
  16. subThreadIns.start()
  17. eventLock.set()#设置为绿灯
  18. eventLock.clear()#设置为红灯
  19. eventLock.set()#设置为绿灯
  20. #startandwaitrunthread:Thread-1
  21. #startandwaitrunthread:Thread-2
  22. #startandwaitrunthread:Thread-3
  23. #greenlight,Thread-1carryonrun
  24. #redlight,Thread-1stoprun
  25. #greenlight,Thread-1carryonrun
  26. #subthreadThread-1runend
  27. #greenlight,Thread-3carryonrun
  28. #redlight,Thread-3stoprun
  29. #greenlight,Thread-3carryonrun
  30. #subthreadThread-3runend
  31. #greenlight,Thread-2carryonrun
  32. #redlight,Thread-2stoprun
  33. #greenlight,Thread-2carryonrun
  34. #subthreadThread-2runend

5、Semaphore() 信号量锁

基本介绍

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

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

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

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

使用方式

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

  1. importthreading
  2. importtime
  3. maxSubThreadNumber=6
  4. deftask():
  5. thName=threading.currentThread().name
  6. semaLock.acquire()
  7. print("runsubthread%s"%thName)
  8. time.sleep(3)
  9. semaLock.release()
  10. if__name__=="__main__":
  11. #每次只能放行2个
  12. semaLock=threading.Semaphore(2)
  13. foriinrange(maxSubThreadNumber):
  14. subThreadIns=threading.Thread(target=task)
  15. subThreadIns.start()
  16. #runsubthreadThread-1
  17. #runsubthreadThread-2
  18. #runsubthreadThread-3
  19. #runsubthreadThread-4
  20. #runsubthreadThread-6
  21. #runsubthreadThread-5

with语句

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

  1. importthreading
  2. importtime
  3. maxSubThreadNumber=6
  4. deftask():
  5. thName=threading.currentThread().name
  6. withsemaLock:
  7. print("runsubthread%s"%thName)
  8. time.sleep(3)
  9. if__name__=="__main__":
  10. semaLock=threading.Semaphore(2)
  11. foriinrange(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. iflockisNone:
  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. exceptAttributeError:
  10. pass
  11. try:
  12. self._acquire_restore=lock._acquire_restore
  13. exceptAttributeError:
  14. pass
  15. try:
  16. self._is_owned=lock._is_owned
  17. exceptAttributeError:
  18. pass
  19. self._waiters=_deque()

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

  1. classEvent:
  2. def__init__(self):
  3. self._cond=Condition(Lock())#实例化出了一个条件锁。
  4. self._flag=False
  5. def_reset_internal_locks(self):
  6. #private!calledbyThread._reset_internal_locksby_after_fork()
  7. self._cond.__init__(Lock())
  8. defis_set(self):
  9. """Returntrueifandonlyiftheinternalflagistrue."""
  10. returnself._flag
  11. isSet=is_set

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

  1. classSemaphore:
  2. def__init__(self,value=1):
  3. ifvalue<0:
  4. raiseValueError("semaphoreinitialvaluemustbe>=0")
  5. self._cond=Condition(Lock())#可以看到，这里是实例化出了一个条件锁
  6. self._value=value

基本练习题

条件锁的应用

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

  1. importthreading
  2. lst=[]
  3. defeven():
  4. """加偶数"""
  5. withcondLock:
  6. foriinrange(2,101,2):
  7. #判断当前列表的长度处于2是否能处尽
  8. #如果能处尽则代表需要添加奇数
  9. #否则就添加偶数
  10. iflen(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. defodd():
  22. """加奇数"""
  23. withcondLock:
  24. foriinrange(1,101,2):
  25. iflen(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. importthreading
  2. deflibai():
  3. event.wait()
  4. print("李白：老杜啊，不喝了我喝不下了！")
  5. event.set()
  6. event.clear()
  7. event.wait()
  8. print("李白：呼呼呼...睡着了..")
  9. defdufu():
  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()

原文地址：https://mp.weixin.qq.com/s/v6EWNgDVCXTBigdv2H9iAQ

标签：

相关文章