Thread实例对象的方法 # isAlive(): 返回线程是否活动的。 # getName(): 返回线程名。 # setName(): 设置线程名。 threading模块提供的一些方法： # threading.currentThread(): 返回当前的线程对象。 # threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。 # threading.activeCount(): 返回正在运行的线程个数，与len(threading.enumerate())有相同的结果。 #threading.main_thread() 返回主线程对象 #threading.get_ident() 返回当前线程的ID，非0整数
例子
import time import threading def func(arg): time.sleep(1) print(arg,threading.current_thread(),threading.get_ident()) #threading.current_thread() 获取当前进程对象， # threading.get_ident(）获取当前线程号 for i in range(10): threading.Thread(target=func,args=(i,)).start() print("线程数量统计",threading.active_count()) #统计当前线程数量 threading.current_thread().setName("主线程") #设置线程名字 print(threading.current_thread().isAlive()) #线程是不是活动的 print("当前线程",threading.current_thread()) print("获取当前线程名字",threading.current_thread().getName()) print("线程变量列表",threading.enumerate()) #以列表的形式显示当前所有的线程变量
二、线程的join（）
与进程的join方法作用类似，线程的 join方法的作用是阻塞，等待子线程结束，join方法有一个参数是timeout，即如果主线程等待timeout，子线程还没有结束，则主线程强制结束子线程。
但是python 默认参数创建线程后，不管主线程是否执行完毕，都会等待子线程执行完毕才一起退出，有无join结果一样。进程没有join（）则在执行主进程完后直接退出，而主线程是等待子线程执行完毕才一起退出。
import threading import time def func(n): time.sleep(2) print("线程是%s"%n) global g g = 0 print(g) if __name__ == '__main__': g = 100 t_l = [] for i in range(5): t = threading.Thread(target=func,args=(i,)) t.start() t_l.append(t) print("线程数量统计1--", threading.active_count()) # 统计当前线程数量，结果是6,5个子线程加1个主线程 for t in t_l: t.join() print('结束了') print("线程数量统计2--", threading.active_count()) # 统计当前线程数量，结果是1，只有一个主线程
三、Thread类的start()和run()方法的区别
start()
import threading import time def add(x, y): for _ in range(5): # _解压序列赋值,_代表不用关心的元素 time.sleep(0.5) print("x+y={}".format(x + y)) class MyThread(threading.Thread): def start(self): print('start-----') super().start() # 调用父类的start()和run()方法 def run(self): print('run-----') super().run() # 调用父类的start()和run()方法 t = MyThread(target=add, name="MyThread", args=(1, 2)) t.start() # t.run() print("====end===")
执行结果：
start----- run----- ====end=== x+y=3 x+y=3 x+y=3 x+y=3 x+y=3
分析：可以看出start()方法会先运行start()方法，再运行run()方法。
从源码简单追踪下start()的调用过程：
1、 def start(self): print('start-----') super().start() # 调用父类的start()和run()方法 2、def start(self): #父类的start（） _start_new_thread(self._bootstrap, ()) #执行_start_new_thread找到_start_new_thread，再次找到_thread.start_new_thread，这里是pass #下一步获取self._bootstrap值找到def _bootstrap，通过self._bootstrap_inner()，最后执行了 #self.run() .... 3、_start_new_thread = _thread.start_new_thread 4、def start_new_thread(function, args, kwargs=None): pass 5、def _bootstrap(self): self._bootstrap_inner() 6、def _bootstrap_inner(self): .... try: self.run()#最终start()方法调用了run()方法 except SystemExit: pass
run()
import threading import time def add(x, y): for _ in range(5): # _解压序列赋值,_代表不用关心的元素 time.sleep(0.5) print("x+y={}".format(x + y)) class MyThread(threading.Thread): def start(self): print('start-----') super().start() # 调用父类的start()和run()方法 def run(self): print('run-----') super().run() # 调用父类的start()和run()方法 t = MyThread(target=add, name="MyThread", args=(1, 2)) # t.start() t.run() print("====end===")
执行结果：
run----- x+y=3 x+y=3 x+y=3 x+y=3 x+y=3 ====end===
分析：运行线程的run()方法只能调用到run()方法。
从源码简单追踪下runt()的调用过程：
1、def run(self): print('run-----') super().run() # 调用父类的start()和run()方法 2、def __init__(self, group=None, target=None, name=None, args=(), kwargs=None, *, daemon=None): self._target = target #这里的_target是个子线程的函数名 self._args = args self._kwargs = kwargs .... 3、def run(self): if self._target: self._target(*self._args, **self._kwargs) #这里就直接执行了这个函数
分析：target是我们传入的目标函数，run()方法其实就类似一个装饰器，最终还是将args 和kwargs 参数传入目标函数运行，返回结果。
继续分析：
start()
import threading import time def func(n): time.sleep(2) print("线程是%s" % n) print('子线程的ID号A', threading.current_thread().ident) global g g = 0 print('子线程中的g', g) class Mythread(threading.Thread): def __init__(self, arg, *args, **kwargs): super().__init__(*args, **kwargs) self.arg = arg def start(self): print('start-----') super().start() # 调用父类的start()和run()方法 def run(self): print('run-----') print("类中的子线程", self.arg) super().run() print('子线程的ID号B',threading.current_thread().ident) if __name__ == '__main__': g = 100 t1 = Mythread('hello', target=func, name="MyThread", args=('nick',)) # 第一个参数是用在Mythread类中的，后面的3个参数用在创建的func子线程中，args必须是可迭代的 # 这里的func也可以直接写在Mythread中的run()里，这时这里的run()不用再继承父类的run() t1.start() #t1.run() print('主线程中的g', g) print('主线程的ID号---', threading.current_thread().ident)
执行结果
start----- run----- 类中的子线程 hello 线程是nick 子线程的ID号A 19672 子线程中的g 0 子线程的ID号B 19672 主线程中的g 0 主线程的ID号--- 12056
分析：可以看到这里有主进程有子线程func()和mythread.run()属于同一子线程，因为mythread.run()继承父类的run()最终还是要执行func()函数的，这里只是在对象中多写了几行。
run（）
import threading import time def func(n): time.sleep(2) print("线程是%s" % n) print('子线程的ID号A', threading.current_thread().ident) global g g = 0 print('子线程中的g', g) class Mythread(threading.Thread): def __init__(self, arg, *args, **kwargs): super().__init__(*args, **kwargs) self.arg = arg def start(self): print('start-----') super().start() # 调用父类的start()和run()方法 def run(self): print('run-----') print("类中的子线程", self.arg) super().run() print('子线程的ID号B',threading.current_thread().ident) if __name__ == '__main__': g = 100 t1 = Mythread('hello', target=func, name="MyThread", args=('nick',)) # 第一个参数是用在Mythread类中的，后面的3个参数用在创建的func子线程中，args必须是可迭代的 # 这里的func也可以直接写在Mythread中的run()里，这时这里的run()不用再继承父类的run() # t1.start() t1.run() print('主线程中的g', g) print('主线程的ID号---', threading.current_thread().ident)
执行结果
run----- 类中的子线程 hello 线程是nick 子线程的ID号A 18332 子线程中的g 0 子线程的ID号B 18332 主线程中的g 0 主线程的ID号--- 18332
分析：这可以看到，程序竟然只有有个线程，那就是主线程。
例子
import threading # 定义准备作为子线程action函数 def action(max): for i in range(max): # 直接调用run()方法时，Thread的name属性返回的是该对象的名字 # 而不是当前线程的名字 # 使用threading.current_thread().name总是获取当前线程的名字 print(threading.current_thread().name + " " + str(i)) # ① for i in range(100): # 调用Thread的currentThread()方法获取当前线程 print(threading.current_thread().name + " " + str(i)) if i == 20: # 直接调用线程对象的run()方法 # 系统会把线程对象当成普通对象，把run()方法当成普通方法 # 所以下面两行代码并不会启动两个线程，而是依次执行两个run()方法 threading.Thread(target=action,args=(100,)).run() threading.Thread(target=action,args=(100,)).run()
上面程序在创建线程对象后，直接调用了线程对象的 run() 方法，程序运行的结果是整个程序只有一个主线程。还有一点需要指出，如果直接调用线程对象的 run() 方法，则在 run() 方法中不能直接通过 name 属性（getName() 方法）来获取当前执行线程的名字，而是需要使用 threading.current_thread() 函数先获取当前线程，然后再调用线程对象的 name 属性来获取线程的名字。
通过上面程序不难看出，启动线程的正确方法是调用 Thread 对象的 start() 方法，而不是直接调用 run() 方法，否则就变成单线程程序了。
需要指出的是，在调用线程对象的 run() 方法之后，该线程己经不再处于新建状态，不要再次调用线程对象的 start() 方法。
注意，只能对处于新建状态的线程调用 start() 方法。也就是说，如果程序对同一个线程重复调用 start() 方法，将引发 RuntimeError 异常。
总结：
从上面四个小例子，我们可以总结出：
-
start() 方法是启动一个子线程
-
run() 方法并不启动一个新线程，就是在主线程中调用了一个普通函数而已。
因此，如果你想启动多线程，就必须使用start()方法。
四、守护线程
守护线程会在"该进程内所有非守护线程全部都运行完毕后,守护线程才会挂掉"。并不是主线程运行完毕后守护线程挂掉。这一点是和守护进程的区别之处！
需要强调的是：运行完毕并非终止运行**。
无论是进程还是线程，都遵循：守护xxx会等待xxx运行完毕后被销毁
进程与线程的守护进（线）程对比
-
对主进程来说，运行完毕指的是主进程代码运行完毕
-
对主线程来说，运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕，主线程才算运行完毕
守护进程：主进程代码运行完毕，守护进程也就结束 （守护的是主进程）
主进程要等非守护进程都运行完毕后再回收子进程的资源（否则会产生僵尸进程）才结束
主进程等子进程是因为主进程要给子进程收尸（代用wait方法向操作系统发起回收资源信号（pid号，状态信息））
守护线程：非守护线程代码运行完毕，守护线程也就结束 （守护的是非守护线程）
主线程在其他非守护线程运行完毕后才算结束（主线程的结束意味着进程的结束，守护线程在此时就会被回收）
强调：主线程也是非守护线程（进程包含了线程）
总结：
-
主线程活着的时候，守护线程才会存活。主线程结束后，守护线程会自动被杀死结束运行。
-
主线程需等所有非守护线程退出后才会退出，如果想要结束非守护线程，我们必须手动找出非守护线程将其杀死。
实例
主线程启动两个子线程：
-
子线程0-守护线程，运行10秒退出
-
子线程1-非守护线程，运行1秒退出。
根据我们上面的总结，我们会知道：
-
主线程启动完子线程，等待所有非守护线程运行
-
非守护子线程1运行1秒退出
-
此时没有非守护线程运行，主线程退出
-
子线程0虽然任务还未完成，但是它是守护线程，会紧跟主线程退出。
例子
# 守护线程 from threading import Thread import time def func1(): while True: print("in func1") time.sleep(5) def func2(): print("in func2") time.sleep(1) t1 = Thread(target=func1,) t1.daemon = True t1.start() t2 = Thread(target=func2,) t2.start() print("主进程")
分析：这里的t1线程作为守护线程一定是执行不完的，因为其他非守护线程很快执行完了，主线程就要结束了，主线程结束进程要回收资源，所以t1作为守护线程马上会被结束掉。
例子2
from threading import Thread import time def foo(): print(123) time.sleep(1) print("end123") def bar(): print(456) time.sleep(3) print("end456") t1=Thread(target=foo) t2=Thread(target=bar) t1.daemon=True t1.start() t2.start() print("主线程-------")
分析：虽然这里设置了t1是守护线程，但是由于t1线程运行的时间较短，所以这里的守护线程会完成运行，不会出现运行一半程序直接退出的情况。