Python3 多线程 threading学习笔记

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

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

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值