python线程（二）代码部分Threading模块
一、threading类简介
1、threading.Thread类参数简介
class threading.Thread(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)
group：目前此参数为None，在实现ThreadGroup类时为将来的扩展保留。
target：target接收的是一个函数的地址，由run()方法调用执行函数中的内容。默认为无，表示未调用任何内容。
name ：线程名，可自行定义。
args：target接收的是函数名，此函数的位置参数以元组的形式存放在args中，用于执行函数时调用。
kwargs ：target接收的是函数名，此函数的关键字参数以字典的形式存放在kwargs中，用于执行函数时调用。
daemon：如果为True表示该线程为守护线程。
2、threading.Thread类的常用方法
start()：开启线程，一个Thread对象只能调用一次start()方法，如果在同一线程对象上多次调用此方法，则会引发RuntimeError。
run()：执行start()方法会调用run()，该方将创建Thread对象时传递给target的函数名，和传递给args、kwargs的参数组合成一个完整的函数，并执行该函数。run()方法一般在自定义Thead类时会用到。
join(timeout=None)：join会阻塞、等待线程，timeout单位为秒，因为join（）总是返回none，所以在设置timeout调用join（timeout）之后，需要使用isalive（）判断线程是否执行完成，如果isalive为True表示线程在规定时间内没有执行完，线程超时。如果join(timeout=None)则会等待线程执行完毕后才会执行join（）后面的代码，一般用于等待线程结束。
name：获取线程名。
getName()：获取线程名。
setName(name)：设置线程名。
ident：“线程标识符”，如果线程尚未启动，则为None。如果线程启动是一个非零整数。
is_alive()：判断线程的存活状态，在run（）方法开始之前，直到run（）方法终止之后。如果线程存活返回True，否则返回False。
daemon：如果thread.daemon=True表示该线程为守护线程，必须在调用Start（）之前设置此项，否则将引发RuntimeError。默认为False
isDaemon()：判断一个线程是否是守护线程。
setDaemon(daemonic)：设置线程为守护线程。
二、threading.Thread的简单使用
创建线程：
from threading import Thread def work(args,kwargs=None): print(args) print(kwargs) if __name__ == "__main__": t = Thread(target=work, args=(("我是位置参数"),), kwargs={'kwargs': '我是关键字参数'}, name='我是线程demo') print(t.name) # 打印线程名 t.start() # 开启线程 print('我是主线程') # 打印内容如下 我是线程demo 我是位置参数 我是关键字参数 我是主线程
由上面的打印内容我们可以看出，在执行完所有线程后才执行的主线程print。如果是多进程的话会先执行主进程中的print然后才会执行子进程的print。主要是因为开启进程相比于开启线程更加耗费时间。
自定义线程类
from threading import Thread def work(args,kwargs=None): print(args) print(kwargs)
class MyThread(Thread): # 使用继承Thread的方式，自定义线程类 def __init__(self,target=None, name=None, args=(), kwargs=None, *, daemon=None): # 如果要给对象封装属性，必须先调用父类 super().__init__() if kwargs is None: kwargs = {} self._target = target self._name = name self._args = args self._kwargs = kwargs def run(self): # 必须要有run类，因为start要调用 print(f"我重写了Thread类的run") self._target(*self._args,**self._kwargs) if __name__ == "__main__": t = MyThread(target=work,args=(('我是位置参数'),),kwargs={'kwargs':'我是关键字参数'},name='我是自定义线程类') # 创建线程对象 print(t.name) # 打印线程名 t.start() # 开启线程 print("主线程") # 打印内容如下 我是自定义线程类 我重写了Thread类的run 主线程 我是位置参数 我是关键字参数
多进程和多线程的效率对比
from threading import Thread from multiprocessing import Process import time def thread_work(name): print(f"{name}") def process_work(name): print(f"{name}") if __name__ == "__main__": # 进程执行效率 pro = [] start = time.time() for i in range(3): p = Process(target=process_work,args=(("进程-"+str(i)),)) p.start() pro.append(p) for i in pro: i.join() end = time.time() print("进程运行了:%s" %(end - start)) # 线程执行效率 thread_l = [] start = time.time() for i in range(3): t = Thread(target=process_work, args=(("线程-" + str(i)),)) t.start() thread_l.append(t) for i in thread_l: i.join() end = time.time() print("进程运行了:%s" % (end - start)) # 打印内容如下 进程-0 进程-1 进程-2 进程运行了:0.18501067161560059 线程-0 线程-1 线程-2 进程运行了:0.004000186920166016
我们可以从时间上看出，线程的效率是远远高于进程的。
守护线程
主线程会等待所有非守护线程执行完毕后，才结束主线程。主进程是进程内的代码结束后就结束主进程。
对比守护进程，代码执行完毕后立即关闭守护进程，因为在主进程看来代码执行完毕，主进程结束了，所以守护进程在代码结束后就被结束了。
守护线程会等待主线程的结束而结束。这是因为如果主线程结束意味着程序结束，主线程会一直等着所有非守护线程结束，回收资源然后退出程序，所以当所有非守护线程结束后，守护线程结束，然后主线程回收资源，结束程序。
下面对比守护进程和守护线程的示例：
先来看守护进程：
from multiprocessing import Process def process_work(name): print(f"{name}") if __name__ == "__main__": p = Process(target=process_work,args=("守护进程")) p.daemon=True p.start() print("主进程") # 打印内容如下 主进程
只打印了主进程，也就是说守护进程还没来得及执行程序就结束了。
再来看守护线程：
from threading import Thread def thread_work(name): print(name) if __name__ == "__main__": t = Thread(target=thread_work,args=("守护线程",)) t.daemon=True t.start() print("\n主线程") # 打印内容如下 守护线程 主线程
也许你会说是由于线程太快了，所以才执行了守护线程。下面我们在线程中阻塞一段时间，在来看看会发生什么效果。
from threading import Thread import time def thread_work(name): time.sleep(3) # 阻塞3秒 print(name) if __name__ == "__main__": t = Thread(target=thread_work,args=("守护线程",)) t.daemon=True t.start() print("\n主线程") # 打印内容如下 主线程 守护线程
守护线程还是被执行了，如果是守护进程，守护进程里的代码是不会被执行的。
线程锁Lock
Lock也称线程同步锁，互斥锁，原子锁，该对象只有两个方法：
acquire(blocking=True, timeout=-1)：加锁。
参数：
blocking：当为True时表示加锁，只允许一个线程执行被加锁的代码。直到遇到release()解锁后其它线程才可以执行加锁部分的代码。当为False时表示不加锁，并且不能调用release()否则会报RuntimeError。
timeout：设置加锁时间，单位为秒。-1表示一直等待线程release()后，才允许其它线程执行加锁的代码。
release()：释放锁。
未加锁的代码示例
from threading import Thread import time def work(): global n temp = n time.sleep(0.1) # 由于线程太快了，所以这里停顿下 n = temp -1 if __name__ == "__main__": n = 100 t_l = [] for i in range(100): t = Thread(target=work,args=()) t.start() t_l.append(t) for i in t_l: i.join() print(n) # 打印内容如下 99
在我们看来其实值应该是0的但却是99，就因为短暂停了0.1秒导致结果发生了变化。而我们这0.1秒的停留是模拟网络延迟或者进程调度等原因。造成了数据的结果的错乱。这个时候我们就需要线程锁来保证数据的安全性。
下面我们就通过给程序加锁，来保证数据的安全性：
from threading import Thread,Lock import time def work(lock): lock.acquire() # 加锁 global n temp = n time.sleep(0.1) # 由于线程太快了，所以这里停顿下 n = temp -1 lock.release() # 解锁 if __name__ == "__main__": n = 100 t_l = [] lock = Lock() # 得到一把锁对象 for i in range(100): t = Thread(target=work,args=(lock,)) t.start() t_l.append(t) for i in t_l: i.join() print(n) # 打印内容如下 0
我们会发现程序和上一个示例的运行效率上有着很大的差别。明显加锁后程序的运行效率降低了，我们管这种锁叫做线程同步锁，使原本并行的程序编程了串行所以程序的效率会慢很多，但是程序的运行结果是正确的。在程序的运行效率和数据的正确性，我们应首先确保程序的正确性然后在考虑程序的效率。
递归锁RLock
死锁与递归锁：
所谓死锁： 是指两个或两个以上的进程或线程在执行过程中，出现了一种互相等待的情况，它们都将无法进行下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程，如下模拟产生死锁。
from threading import Lock,Thread def work(): # 获取锁 lock.acquire() print("我是工作线程 1") # 释放锁 lock.release() def work_2(): # 获取锁 lock.acquire() print("我是工作线程 2") work() # 调用工作线程1，造成死锁 # 释放锁 lock.release() if __name__ == '__main__': # 生成lock实例 lock = Lock() # 开始3个线程 for i in range(3): t = Thread(target=work_2) t.start() print('我是主线程') # 打印内容如下 我是主线程 我是工作线程 2 # 此时程序处于死锁状态
我们可以理解为一把锁对象只能创建一把锁，这把锁必须release后，才能再次使用。否则程序就会被锁住，等待解锁。如上面的代码，work_2执行创建一个lock锁，调用work又遇到一把lock锁，而在work_2中的lock锁没有被解锁，所以程序在work中等待lock解锁，最终造成了程序出现了死锁，下面我们使用递归锁RLock来解决上面的问题。
关于RLock的用法及方法一样，所以这里就不再重复了。
使用RLock避免死锁：
from threading import RLock,Thread def work(): # 获取锁 lock.acquire() print("我是工作线程 1") # 释放锁 lock.release() def work_2(): # 获取锁 lock.acquire() print("我是工作线程 2") work() # 调用工作线程1，造成死锁 # 释放锁 lock.release() if __name__ == '__main__': # 使用递归锁RLock lock = RLock() # 开始3个线程 for i in range(3): t = Thread(target=work_2) t.start() print('我是主线程') # 打印内容如下 我是工作线程 2 我是工作线程 1 我是工作线程 2 我是工作线程 1 我是工作线程 2 我是主线程 我是工作线程 1
使用递归锁后程序运行正常了。
条件对象Condition(lock=None)
Condition条件变量，与锁相关联，在实例化对象时可以给其传入一把锁，如果不传，会默认创建一把递归锁。目前我对它的就理解是它是一把带通知，挂起线程功能的锁。它可以挂起线程，然后发送通知激活线程，并且还可以加锁，属于一把高级锁，下面我们来看看常用的方法。
1、Condition类的方法
class threading.Condition([lock])
acquire()：加锁、与Lock、RLock中的用法一致，这里不过多解释。
release()：解锁、与Lock、RLock中的用法一致，这里不过多解释。
wait(timeout=None)：挂起线程，如果timeout是None则必须等到notify或notify_all后线程才会被激活，并且被激活的线程会重新获取到一把锁，线程被激活后从wait挂起的位置继续向下执行。如果指定timeout超时时间，单位为秒，表示线程挂起一段时间后在继续执行。注意：如果调用线程在调用此方法时未获取锁，则会引发RuntimeError。
wait_for(predicate, timeout=None)：这个不知道该如何解释。
notify(n=1)：激活被挂起的线程，n表示激活n个被挂起的线程，注意：如果调用线程在调用此方法时未获取锁，则会引发RuntimeError。
notify_all()：激活所有被挂起的线程，注意：如果调用线程在调用此方法时未获取锁，则会引发RuntimeError。。
2、下面是一个无聊的实例：
from threading import Condition,Thread import time def consume(): '''消费者''' global cv global num cv.acquire() while True: num -= 1 if num <= 0: print('-' * 20) cv.notify() # 激活生产者线程 cv.wait() print(f'消费数据-{num}') time.sleep(2) cv.release() def produce(): '''生产者''' global cv global num cv.acquire() while 1: num += 1 print(f'生产数据-{num}') if num >= 5: print('-' * 20) cv.notify() # 激活消费者线程 cv.wait() time.sleep(0.5) cv.release() if __name__ == '__main__': cv = Condition() # 实例化条件对象 num = 0 # 开启线程 produce_t = Thread(target=produce, args=()) consume_t = Thread(target=consume, args=()) produce_t.start() consume_t.start()
Threading类的方法：
threading.active_count()：获取当前活动的线程对象数量。
threading.current_thread()：获取当前的线程对象。如果调用方的控制线程不是通过线程模块创建的，则返回功能有限的虚拟线程对象。
threading.get_ident()：获取线程标识符。
threading.enumerate()：这个比较厉害，可以获取当前活动的所有线程对象的列表。该列表包括后台线程和使用current_thread()创建的虚拟线程。以列表的形式返回。
threading.main_thread()：获取主线程对象。
Threading模块就简单介绍到这里吧，参考文档：https://docs.python.org/3/library/threading.html#threading.Condition.notify
下一篇：python协程简介：https://www.cnblogs.com/caesar-id/p/10771369.html
