Python中的threading模块提供了对用线程的相关操作，线程是应用程序中工作的最小单元。
1.Thread类
Thread是线程类，有两种使用方法，从Thread类继承并覆盖run方法，或者直接传入要运行的方法。
1 # -*- coding:utf-8 -*- 2 3 import threading 4 import time 5 6 def func(): 7 time.sleep(2) 8 print("func") 9 10 def main(): 11 t = threading.Thread(target=func) # 将要执行的方法作为参数传递给Thread类的构造方法 12 t.start() 13 14 15 16 17 if __name__ == ‘__main__‘: 18 main()
19 print("the main thread is end")
1 # -*- coding:utf-8 -*- 2 3 import threading 4 import time 5 6 class MyThread(threading.Thread): 7 def __init__(self): 8 super(MyThread, self).__init__() # 一定要显示的调用父类的初始化方法 9 10 def run(self): # 覆盖run方法 11 time.sleep(2) 12 print("func") 13 14 15 def main(): 16 t = MyThread() 17 t.start() 18 19 20 if __name__ == ‘__main__‘: 21 main() 22 print("the main thread is end")
Thread类的构造方法：
Thread(group=None,target=None,name=None,args=(),kwargs={})
group：线程组，还未实现。
target：要执行的方法；
name：线程名；
args/kwargs：要传入的方法的参数；
Thread实例的方法：
isAlive：县城是否还在运行。
get/setName(name)：获取/设置线程名
start()：线程准备就绪，等待CPU调度。
is/setDaemon(bool)：获取/设置是后台线程，在start之前进行设置。
说明：如果是后台线程，主线程执行完毕后，不论后台线程成功与否，主线程和后台线程均会停止;如果是前台线程，主线程执行完毕后，需要等待后台线程执行完毕后，程序才会停止。
start()：启动线程。
join(timeout)：阻塞当前上下文环境线程，直到调用此方法的线程终止或达到设置的超时时间（timeout）。
示例
未设置isDaemon：
1 # -*- coding:utf-8 -*- 2 3 import threading 4 import time 5 6 def func(): 7 time.sleep(2) 8 print("func--", threading.current_thread().getName()) 9 10 def main(): 11 t = threading.Thread(target=func) 12 t.start() 13 14 15 if __name__ == ‘__main__‘: 16 main() 17 print("main thread is end") 18 19 20 -----输出结果----- 21 22 main thread is end 23 func-- Thread-1
当没有设置Daemon的情况下（默认为false），主线程执行结束后，需要等待前台线程执行完之后，程序才会停止。
设置isDaemon为True：
1 # -*- coding:utf-8 -*- 2 3 import threading 4 import time 5 6 def func(): 7 time.sleep(2) 8 print("func--", threading.current_thread().getName()) 9 10 def main(): 11 t = threading.Thread(target=func) 12 t.setDaemon(True) 13 t.start() 14 15 16 if __name__ == ‘__main__‘: 17 main() 18 print("main thread is end") 19 20 -------输出结果-------- 21 main thread is end
当设置了Dameon为True时，当主线程执行完毕后，程序即结束，不会等待后台线程执行完之后再结束程序。
设置join：
join的作用是完成线程的同步，也就是主线程执行完毕之后，进入阻塞状态，一直等到其他的子线程执行完毕后，主线程才结束。
1 # -*- coding:utf-8 -*- 2 3 import threading 4 import time 5 6 def func(): 7 time.sleep(2) 8 print("func--", threading.current_thread().getName()) 9 10 def main(): 11 for i in range(5): 12 t = threading.Thread(target=func) 13 t.setDaemon(True) 14 t.start() 15 t.join() 16 17 18 if __name__ == ‘__main__‘: 19 main() 20 print("main thread is end") 21 22 ------输出结果-------- 23 24 func-- Thread-1 25 func-- Thread-2 26 func-- Thread-3 27 func-- Thread-4 28 func-- Thread-5 29 main thread is end
线程锁：
由于线程之间可以共享数据，在多个线程同时操作一个变量时，可能会产生数据混乱，如下示例：
1 # -*- coding:utf-8 -*- 2 3 import threading 4 import time 5 6 num = 0 7 8 def func(n): 9 global num 10 time.sleep(1) 11 num = num + n 12 print(num) 13 14 15 if __name__ == ‘__main__‘: 16 17 for i in range(10): 18 t = threading.Thread(target=func, args=(i, )) 19 t.start() 20 21 -------输出结果------- 22 23 2 24 2 25 3 26 6 27 14 28 21 29 26 30 32 31 36 32 45
数据混乱，我们想要的是0,1,3,6,10....，现在使用Lock进行加锁：
1 # -*- coding:utf-8 -*- 2 3 import threading 4 import time 5 6 num = 0 7 lock = threading.Lock() 8 9 10 def func(n): 11 lock.acquire() 12 global num 13 time.sleep(1) 14 num = num + n 15 print(num) 16 lock.release() 17 18 19 if __name__ == ‘__main__‘: 20 21 for i in range(10): 22 t = threading.Thread(target=func, args=(i, )) 23 t.start() 24 25 -------输出结果--------- 26 27 0 28 1 29 3 30 6 31 10 32 15 33 21 34 28 35 36 36 45
原文：https://www.cnblogs.com/zhuzhaoli/p/10664359.html