Python3 多线程 threading学习笔记

最新推荐文章于 2024-05-16 15:52:17 发布

阿刁阿

最新推荐文章于 2024-05-16 15:52:17 发布

阅读量515

点赞数 2

分类专栏： Python

本文链接：https://blog.csdn.net/lc_buzhidao/article/details/99698583

版权

Python 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

先了解下进程和线程是个什么东西

这两个概念与操作系统的知识关系密切的，暂时只能先总结下基础概念。待以后看有没有必要系统学习。对这一块知识，我有种盲人摸象的感觉。所以总结起来难免不全面，或者出现错误。若发现了，请帮忙指正。
进程：
了解进程之前，了解下进程是怎么来的或许有帮助。
我们放在磁盘上的各种软件，可以称作【程序】；这个时候我们的软件和操作系统的几乎没什么关系。当一个程序被选中执行后，就可以称作【作业】；当作业被载入内存时，就变成了进程。进程是一个驻留在内存中的作业，也可以理解为是一个驻留在内存中的程序。这就是我们磁盘上的软件变成操作系统中一个进程的大致过程。这个过程请参考如下图：
在这里插入图片描述
当作业被载入内存时，操作系统就会为其分配系统资源。所以有个大家都在总结的一句话是：进程是操作系统分配资源的最小单位。
进程一般分为三个状态：运行、阻塞、就绪。不过也还有另外两个状态：创建、退出。
一个操作系统有很多任务要处理，但计算机资源是有限的，所以操作系统中有各种队列来处理这种场景。即没有得到系统资源的任务就先乖乖的排队，这个场景和我们平时在饭堂各个窗口排队打饭差不多。
进程所在的队列由进程管理器负责处理。当进程在不同类型的队列当中，就可以看作进程处于不同的状态。
进程和线程从本质上来说，是个虚拟的东西。我们只好想象一下，进程所在的世界发生了啥。假如是这样的：一个程序被选中执行的时候，挺高兴，终于升职成为作业了。到了新衙门一看，前面排着一群作业，一颗准备大展宏图的心瞬间凉了，凉了之后就得面对现实，加入到了队列中。这个队列就叫做【作业队列】。一群在排队的作业（这么说对于学生身份的人好像不大友好哈），百无聊赖打着哈欠之际，内存中有人跑过来说，这边的坑空了一个，下一个谁啊赶紧上。接着排在作业队列最前面的那个作业，就被载入内存，成为一名光荣的进程。这种队列方式，可以看作是先入先出队列。这个作业进入了新的衙门任职进程，这个新的衙门也就是内存。
作业进入内存之后变成了进程后，才会知道现实无论在哪里都是现实。因为他一来又得排队。
作业进入内存之后，这个时候是进程了，首先会在【就绪队列】中排队，这个时候进程的状态可以看作就绪状态。当在就绪队列中排完对之后，就得到了CPU分配的时间片，去CPU那遨游了一圈，这个时候的进程是运行状态。当进程运行的时候，突然说有IO需求，我们也该知道接下来会发生什么了。继续排队，没毛病。这次是去【I/O队列】排队，因为需要IO需求的也不只一个进程。当进程在IO队列中时，可以看作是阻塞状态。当这个进程拿到I/O权限的时候，也不是立即返回到CPU那继续运行的，而是需要再去就绪队列那重新排队。
以上整个过程，请参考如下图：图片简洁明了，请允许我给自己加了这么多戏。
在这里插入图片描述

线程：
线程的概念，百度百科是这样说的：线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。
线程是怎么来的，借鉴百度百科：线程的引入： 60年代，在OS中能拥有资源和独立运行的基本单位是进程，然而随着计算机技术的发展，进程出现了很多弊端，一是由于进程是资源拥有者，创建、撤消与切换存在较大的时空开销，因此需要引入轻型进程；二是由于对称多处理机（SMP）出现，可以满足多个运行单位，而多个进程并行开销过大。因此在80年代，出现了能独立运行的基本单位——线程（Threads）。 大概意思就是，线程是计算机发展的产物。当到了某个时代，就诞生了线程这样一个东西的需求。
线程来源于进程，是进程的一个执行单位。所以其特性之一：同一个进程下的所有线程共享进程所拥有的全部资源。
按照线程的诞生历史，当时OS中拥有资源和独立运行的基本单位是进程。处理任务时，要么多个进程一起去处理，要么一个进程轮流处理各个任务。这种方式对对操作系统和对进程本身都不友好，前一种可以比作操作系统这个老板要多发工资，后一种可以比作一个进程要干多个人的活，但又不能分身，累的不行。线程可以比作进程的分身，当一个进程需要处理多个任务时，就分身一个线程去处理。而且多个线程还可以并发运行。那么总结出来就是，线程可以理解进程的一个分身，进程的一些特性，线程也可以有。具体哪些特性，待以后接触多了再慢慢了解。

我们的主题：threading

首先感谢下前辈们把多线程做了优秀的封装，让后进之我使用多线程的门槛降低了一大截。
Python3提供了threading模块来支持多线程的使用。
附上学习文档：
https://docs.python.org/3/library/threading.html?highlight=threading#
threading模块提供了一些方法，和一些对象。这些方法和对象可以使得我们科学的使用多线程。其中threading.Thread这个线程对象是用来创建线程的。

简单了解下threading提供的部分方法：

threading.active_count()  #返回值是个整型数，返回当前活动的线程数量。需要注意的是，如果当前有两个你自己创建子线程在运行，那这时候这个方法会返回3.包含一个主线程。
threading.current_thread() #返回值是个线程对象。返回当前Thread对象。可以理解为：虽然是多线程并发，但其实只是看起来同步执行。一个时刻其实只有一个线程在运行。这个方法就是返回该时刻运行的线程对象。
threading.get_ident() #返回值是个非零整数，返回当前线程对象的“线程标识符”。需要注意的是，这个线程标识符在每次线程被创建的时候被赋予一个新值。在线程退出并创建另一个线程时，线程标识符被回收。
threading.enumerate() #返回值是个对象列表。返回当前活动的所有线程对象的列表。
threading.main_thread() #返回值是个线程对象。返回主线程对象。
threading.settrace(func) 
#这个方法：文档中解释为：
#Set a trace function for all threads started from the threading module. 
#The func will be passed to sys.settrace() for each thread, before its run() method is called.
#大意是从threading启动的每一个线程，这个方法将设置一个追踪函数。追踪函数作为参数传入，并且这个传入的动作在线程对象的run方法被调用之前。run方法调用的时候就是执行threading.Thread.start()的时候。之所以说这么多，是因为我没搞懂这个方法具体怎么使用。
threading.setprofile(func) #和上个方法差不多，不过这次是为线程设置profile函数。同样没搞懂具体怎么用。
threading.stack_size() #返回值是个整型数。返回创建新线程时使用的线程堆栈大小。这个方法还有别的功能，但感觉自己没有理解透，无法归纳。所以建议看原文档。
threading.TIMEOUT_MAX #这是个属性，用来限制阻断函数（比如Lock.acquire(), RLock.acquire(), Condition.wait()等）的超时参数的最大值，Specifying a timeout greater than this value will raise an OverflowError.试了下，不才还是不知道具体怎么用。

threading.Thread线程对象：

了解下Thread对象参数

class threading.Thread(group=None, target=None, name=None, args=(), kwargs={},  daemon=None)
#参数的含义：
#group:默认为None,目前也应该为None，是为以后拓展而保留的
#target:默认为None，这个参数应该被赋予一个函数名，该函数将用于Thread.run()方法调用。可以理解为线程运行时是从这个函数开始的。为None代表run()方法不调用任何函数。
#name:线程的名字，自定义。默认为None。
#args:应该被赋予一个元组。元组中是被调用函数的参数，以位置参数的形式表达。
#kwargs:应该被赋予一个字典。字典中是被调用函数的参数，以关键字参数的方式表达。
#daemon:If not None, daemon explicitly sets whether the thread is daemonic. If None (the default), the daemonic property is inherited from the current thread.大意是：默认是None,创建的线程是否是守护线程会继承自当前线程（莫非是主线程？），反正一般是None的话，该线程就不是守护线程。不是None的话，就显示地设置该线程为守护线程。守护线程地含义后面会作特别说明。

接下来了解下threading.Thread会提供哪些属性和方法：

Thread.start() #该方法负责启动线程，并且在启动的线程中调用Thread.run()方法。每个线程只能调用一次start()方法，若多次调用，将raise一个RuntimeError错误。
Thread.run() #该方法代表线程所作的活动。标准的run方法的作用是调用target参数传递进来的函数。如果一个类继承了threading.Thread类，可以在子类里重载这个run方法。
Thread.join(timeout=None) #该方法会阻塞调用线程（请注意，是调用线程，即调用使用join方法的子线程的线程，大多数情况下，该调用线程为主线程）。会阻塞到什么时候呢，阻塞到使用join方法的子线程终结，或者时间达到timuout计数后超时。当join函数自定义设置了timeout参数后，当阻塞结束后如何判断是因为子线程终结还是超时导致的呢。可以通过在join()方法之后调用threading.Thread.is_alive()方法来判断，如果该方法返回True，则证明子线程还是活动的，那么阻塞是因为超时结束的。如果该方法返回False，则证明子线程是非活动的，那么阻塞是因为子线程终结而结束的。timoout默认是None，应该是一个浮点数，以秒为单位（或其分数）
Thread.name #这是一个属性，用来标识线程的名字。
Thread.getName()
Thread.setName() #Thread.name属性可以取代这两个方法的作用。这两个方法也很简单，直接操作Thread.name属性。设置name，或者获取name.
Thread.ident #这是一个属性，该线程的线程标识符。当线程未被启动时，该值为None。当线程启动时，该值被赋予一个非零整数，当线程被终结时，该值被回收，即该值仍然等于线程启动后被赋予的非零整数值。
Thread.is_alive() #该方法在之前有提及，返回子线程的活动状态。当子线程是活动的，返回True，当子线程是非活动的，返回False。
Thread.daemon #这是一个属性，是一个布尔值。用来设置该线程是否是守护线程。默认是False，如果需要自定义设置的话，必须在threading.Thread.start()方法调用之前设置。

了解下如何创建子线程
threading.Thread用来创建子线程，可以使用两种方法来创建子线程：
第一种方法：实例化一个Thread线程对象，将可调用函数（func_name）和函数参数（arg）传递给构造函数。这种方法很直观，很容易理解子线程是怎么来的，又是怎么结束的。

from threading import Thread
import time

#定义子线程的可调用函数
def test_thread(name):	
	print(name)
	time.sleep(3)
	print('z')
	
#定义子线程的可调用函数
def test_thread_2(name):
	print(name)
	time.sleep(2)
	print('v')
	
#实例化一个子线程对象,target传递可调用函数，args传递可调用函数需要的参数。
t1 = Thread(target = test_thread, name = 't1',args = ('t1',))
#再实例化一个子线程对象
t2 = Thread(target = test_thread_2, name = 't2',args = ('t2',))

#启动子线程t1和t2
t1.start()
t2.start()

#t1子线程调用阻塞方法join.这里阻塞的是主线程。因为是主线程调用的t1子线程。
t1.join()
print('1')
#t2线程调用join方法。阻塞的是主线程。但当程序运行到这里时，t2子线程早已经终结。
t2.join()

print('Over')

输出结果：
t1
t2
v
z
1
Over
[Finished in 4.0s]
#从这个输出结果中可以看出，print('1')是在t1子线程被终结后才开始执行的，之前因为被阻塞，所以无法执行。

第二种方法：通过继承Thread对象创建子类。
这种方法有两点需要注意的地方：
1.最多重载Thread对象中的__init__()和run()方法。不应该在子类中重载其他方法。
2.如果子类重载了__init__构造函数，那么第一步必须是调用基类的构造函数Thread.init()
这两点的具体原理怎样先不管，反正就是要这样做。

from threading import Thread

#创建一个子类，继承自Thread对象
class subThread(Thread):
	#重载构造函数
	def __init__(self,args):
		#调用基类的构造函数，必要的一步
		Thread.__init__(self)
		self.args = args

	#重载Thread.run()方法
	def run(self):
		print(self.args)

t1 = subThread('thread_01')
t1.start()
print('over')

输出结果：
thread_01
over
[Finished in 0.9s]

上面这个简单的例子描述了如何通过继承Thread对象，重载run方法来创建子线程。这种写法主要用于理解，但在实际应用中存在局限性。即子线程的活动内容被写死在子类的run()方法中，那么一个子类就被限制了只能做一件事。如果需要一个子线程做别的事，难道我们又要创建一个子类么？所以个人觉得下面的这种写法更好。

from threading import Thread

#创建一个类，继承自Thread对象
class subThread(Thread):
	#重载构造函数
	def __init__(self,func,args):
		#调用基类的构造函数，必要的一步
		Thread.__init__(self)
		self.func = func
		self.args = args

	#重载Thread.run()方法
	def run(self):
		#带一个*号的参数，代表可以收集位置参数
		#若是带两个*号的参数，代表可以收集关键字参数
		self.func(*self.args)

#定义子线程的可调用函数，该函数说明子线程的活动内容
def print_params(name,age,sex,city):
	print(name)
	print(age)
	print(sex)
	print(city)


#实例化一个subThread类，可调用函数及其参数通过形参传递给构造函数
#可调用函数和子线程对象实现了分离，降低了耦合。可调用函数可进行自定义。
t1 = subThread(print_params,('阿刁',26,'male','广州'))

t1.start()
t1.join()
print('over')

输出结果：
阿刁
26
male
广州
over
[Finished in 0.9s]

以上，就是创建子线程的两种方法。

了解下守护线程

官方文档的释义较简单，大概是这两句话：

当仅仅守护线程存在时，则Python程序会退出。
当没有活动的非守护线程，则Python程序会退出。
还有一个需要注意的提示：
如果一个非守护线程被突然中断会导致它们的资源无法释放，那么建议将这个线程设置为非守护的并且使用合适的信号机制。

给人的感觉守护线程的地位有点低啊。是吧。
守护线程是否结束了，好像没人理。而非守护线程如果没结束，那么Python程序就不会结束，如果所有的非守护线程都结束了，即使守护线程没有结束，那Pyhton程序也会结束；Python程序都结束了，那么守护线程自然也会被中断并结束。
守护线程的命运和古代给帝王陪葬的妃子有点类似呀。

看这个例子，说明所有非守护线程结束后，主程序退出，守护线程也会中断并退出

from threading import Thread
import time

def test_thread(name):	
	time.sleep(3)
	print(name)

def test_thread_2(name):
	print(name)

t1 = Thread(target = test_thread, name = 't1',args = ('t1',))
t2 = Thread(target = test_thread_2, name = 't2',args = ('t2',))

t1.daemon = True
t1.start()
t2.start()
print('Over')

输出结果：
t2
Over
[Finished in 1.0s]

接下来看这个例子，说明当守护线程结束后，非守护线程还在运行，Python程序也不会结束

from threading import Thread
import time

def test_thread(name):	
	print(name)

def test_thread_2(name):
	time.sleep(3)
	print(name)

t1 = Thread(target = test_thread, name = 't1',args = ('t1',))
t2 = Thread(target = test_thread_2, name = 't2',args = ('t2',))

t1.daemon = True
t1.start()
t2.start()
print('Over')

输出结果：
t1
Over
t2
[Finished in 3.9s]

在实际应用中，其中一种情况是：守护线程可以用来处理接受客户请求的任务，如果没有客户请求，他就一直等着，啥也不用干。当有客户请求时，就处理下。如果当主程序都结束了，那么他也可以下班了，因为这个时候处理客户请求也没意义。而主程序结束，也不会注意这个守护线程怎么样了，因为无论他怎么样，都不会影响任何东西。所以，通过这样一个场景，可以理解守护线程的意义。

最后

threading模块中还提供其他的对象，比如锁、事件、信号量、条件、定时器等等对象。
这些对象的意义在于管理多线程运行。
就像当一个只有3个人的创业公司，做事很自由和随意。而一个十万人的公司，工作规范就需要各种制度和流程来规范怎样做事。
当多个线程并发运行时，合理的使用这些对象就可以是的我们的程序有序高效的运行。

阿刁阿

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
2
评论
Python3 多线程 threading学习笔记

先了解下进程和线程理论基础感觉这一块涉及的专业知识还是比较深入的，暂时只能先总结下基础概念。待以后看有没有必要系统学习。了解进程之前，了解下进程是怎么来的或许有帮助。我们放在磁盘上的各种软件，可以称作【程序】；这个时候我们的软件和操作系统的几乎没什么关系。当一个程序被选中执行后，就可以称作【作业】；当作业被载入内存时，就变成了进程。进程是一个驻留在内存中的作业，也可以理解为是一个驻留在内存中...
复制链接

扫一扫

专栏目录