Python的thread模块，是不支持守护线程的。当主线程退出的时候，所有的子线程都将终止，不管他们是否仍在工作。本节我们开始介绍python的另外多线程模块threading，该模块支持守护线程，其工作方式：守护线程一般是一个等待客户端请求的服务器。
如果没有客户端请求，守护线程就是空闲的。如果把一个线程设置为守护线程，就表示这个线程是不重要的，进程退出时不需要等待这个线程执行完成。
如果主线程准备退出的时候，不需要等待某些子线程完成，就可以为这些子线程设置守护线程标记。该标记值为真的时候，标示线程是不重要的，或者说该线程只是用来等待客户端请求而不做其他任何事情。
使用下面的语句：thread.daemon=True 可以将一个线程设置为守护线程。同样的也可以通过这个值来查看线程的守护状态。一个新的子线程会继承父线程的守护标记。整个python程序（也可以称作主线程）将在所有的非守护线程退出之后才退出。
threading模块除了Thread类之外，还包括许多好用的同步机制：
其中，Thread类是threading模块的主要执行对象。
下面是Thread类的属性和方法列表：
使用Thread类，可以有多种方法创建线程：
- 创建Thread类的实例，传递一个函数
- 创建Thread类的实例，传递一个可调用的类实例
- 派生Thread类的子类，并创建子类的实例
一般的，我们会采用第一种或者第三种方法。如果需要一个更加符合面向对象的接口时，倾向于选择第三种方法，否则就用第一种方法吧。
第一种方法：创建Thread类，传递一个函数
下面的脚本中，我们先实例化Thread类，并传递一个函数（及其参数），当线程执行的时候，函数也会被执行：
'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
import threading
from time import sleep,ctime
#不再把4秒和2秒硬性的编码到不同的函数中，而是使用唯一的loop()函数，并把这些常量放进列表loops中
loops=[4,2]
def loop(nloop,nsec):
print('开始循环',nloop,'at:',ctime())
sleep(nsec)
print('循环',nloop,'结束于：',ctime())
def main():
print('程序开始于：',ctime())
threads=[]
nloops=range(len(loops))
for i in nloops:
t=threading.Thread(target=loop,args=(i,loops[i]))
#循环 实例化2个Thread类，传递函数及其参数，并将线程对象放入一个列表中
threads.append(t)
for i in nloops:
threads[i].start() #循环 开始线程
for i in nloops:
threads[i].join() #循环 join()方法可以让主线程等待所有的线程都执行完毕。
print('任务完成于：',ctime())
main()
和thread模块相比，不同点在于：实现同样的效果，thread模块需要锁对象，而threading模块的Thread类不需要。实例化Thread（调用Thread()）和调用thread.start_new_thread()的最大区别就是新线程不会立即执行！这是一个非常有用的同步功能，尤其在我们不希望线程立即开始执行的时候。
当所有的线程都分配完成之后，通过调用每个线程的start()方法再让他们开始。相比于thread模块的管理一组锁（分配、获取、释放检查锁状态）来说，threading模块的Thread类只需要为每个线程调用join()方法即可。join(timeout=None)方法将等待线程结束，或者是达到指定的timeout时间时。这种锁又称为自旋锁。
最重要的是：join()方法，其实你根本不需要调用它。一旦线程启动，就会一直执行，直到给定的函数完成后退出。如果主线程还有其他事情要做（并不需要等待这些线程完成），可以不调用join()。join()只有在你需要等待线程完成时候才是有用的。
例如上面的脚本中，我们注释掉join()代码：
import threading
from time import sleep,ctime
#不再把4秒和2秒硬性的编码到不同的函数中，而是使用唯一的loop()函数，并把这些常量放进列表loops中
loops=[4,2]
def loop(nloop,nsec):
print('开始循环',nloop,'at:',ctime())
sleep(nsec)
print('循环',nloop,'结束于：',ctime())
def main():
print('程序开始于：',ctime())
threads=[]
nloops=range(len(loops))
for i in nloops:
t=threading.Thread(target=loop,args=(i,loops[i])) #循环 实例化2个Thread类，传递函数及其参数，并将线程对象放入一个列表中
threads.append(t)
for i in nloops:
threads[i].start() #循环 开始线程
#for i in nloops:
#threads[i].join() #循环 join()方法可以让主线程等待所有的线程都执行完毕。
print('任务完成于：',ctime())
main()
我们发现：主线程的任务比两个循环线程要先执行（任务完成于……在 循环X结束……的前面）
第二种方法：创建Thread类的实例，传递一个可调用的类实例
创建线程时，于传入函数类似的方法是传入一个可调用的类的实例，用于线程执行——这种方法更加接近面向对象的多线程编程。比起一个函数或者从一个函数组中选择而言，这种可调用的类包含一个执行环境，有更好的灵活性。
在上述的mtsleepC.py脚本中添加一个新类ThreadFunc，稍微改动一番，形成mtsleepD.py文件：
'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
#!/usr/bin/env python
import threading
from time import sleep,ctime
loops=[4,2]
class ThreadFunc(object):
def __init__(self,func,args,name=''):
self.name=name
self.func = func
self.args=args
def __call__(self):
self.func(*self.args)
def loop(nloop,nsec):
print('开始循环',nloop,'在：',ctime())
sleep(nsec)
print('结束循环',nloop,'于：',ctime())
def main():
print('程序开始于：',ctime())
threads = []
nloops = range(len(loops))
for i in nloops:
t = threading.Thread(target=ThreadFunc(loop,(i,loops[i]),loop.__name__)) #传递一个可调用类的实例
threads.append(t)
for i in nloops:
threads[i].start() #开始所有的线程
for i in nloops:
threads[i].join() #等待所有的线程执行完毕
print('任务完成于：',ctime())
main()
上述脚本中，主要添加了ThreadFunc类，并在实例化Thread对象时，通过传参的形式同时实例化了可调用类ThreadFunc。这里同时完成了两个实例化。
我们研究一下创建ThreadFunc类的思想：我们希望这个类更加通用，而不是局限于loop()函数，为此，添加了一些新的东西，比如这个类保存了函数自身、函数的参数、以及函数名。构造函数__init__()用于设定上述值。当创建新线程的时候，Thread类的代码将调用ThreadFunc对象，此时会调用__call__()这个特殊方法。
第三种方法：派生Thread的子类，并创建子类的实例
和方法二相比，方法三再创建线程时使用子类要相对更容易阅读，下面是mtsleepE.py脚本：
#！/usr/bin/env pyhton
import threading
from time import sleep,ctime
loops=[4,2]
class MyThread(threading.Thread):
def __init__(self,func,args,name=''):
threading.Thread.__init__(self)
self.name = name
self.func = func
self.args = args
def run(self):
self.func(*self.args)
def loop(nloop,nsec):
print('开始循环',nloop,'在：',ctime())
sleep(nsec)
print('结束循环',nloop,'于：',ctime())
def main():
print('程序开始于：',ctime())
threads = []
nloops = range(len(loops))
for i in nloops:
t = MyThread(loop,(i,loops[i]),loop.__name__)
threads.append(t)
for i in nloops:
threads[i].start()
for i in nloops:
threads[i].join()
print('所有的任务完成于：',ctime())
main()
比较方法二和方法三，重要的变化在于：MyThread子类的构造函数必须先调用其父类的构造函数；重写run()方法，代替方法二中的__call__()方法。
优化第三种方法：
对MyThread类进行修改，增加一些调试信息的输出，另外，除了简单的调用函数外，还可以将结果保存在实例的属性self.res中，同时增加新的方法getResult()来获取这个值：
以下代码比较了递归求斐波那契、阶乘和累计函数的执行，分别按照单线程和多线程的方式执行同样的任务：
'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
#!/usr/bin/env python
import threading
from time import ctime,sleep
#对MyThread进行封装
class MyThread(threading.Thread):
def __init__(self,func,args,name=''):
threading.Thread.__init__(self)
self.func = func
self.name = name
self.args = args
def run(self):
print('开始执行',self.name,' 在：',ctime())
self.res = self.func(*self.args)
print(self.name,'结束于：',ctime())
def getResult(self):
return self.res
#斐波那契
def fib(x):
sleep(0.005)
if x < 2:
return 1
return fib(x-1)+fib(x-2)
#阶乘
def fac(x):
sleep(0.1)
if x < 2:
return 1
return x*fac(x-1)
#累加
def sum(x):
sleep(0.1)
if x < 2 :
return 1
return x + sum(x-1)
funcs=[fib,fac,sum]
n = 12
def main():
nfuncs = range(len(funcs))
#单线程
print('单线程模式')
for i in nfuncs:
print('开始',funcs[i].__name__,' 在：',ctime())
print(funcs[i](n))
print(funcs[i].__name__,'结束于：',ctime())
#多线程
print('多线程模式')
threads = []
for i in nfuncs :
t = MyThread(funcs[i],(n,),funcs[i].__name__)
threads.append(t)
for i in nfuncs:
threads[i].start()
for i in nfuncs:
threads[i].join()
print(threads[i].getResult())
print('所有的任务结束')
main()
总结
程序中，为了看到多线程如何改善性能的，我们加入了sleep函数用于减慢执行速度。
看到单线程模式中，只是简单的一次调用每个函数，并在函数结束执行的时候立即显示相关的结果；而使用多线程的时候，并不会立刻显示结果，因为我们希望MyThread类越通用越好（有输出和无输出都能执行），我们一直等到所有线程都join之后，再调用getResult()方法显示每个函数的返回值。
扫一扫
1792
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
