1.线程的创建 1.1 通过thread类直接创建 import threading import time def foo(n): time.sleep(n) print("foo func:",n) def bar(n): time.sleep(n) print("bar func:",n) s1=time.time() #创建一个线程实例t1,foo为这个线程要运行的函数 t1=threading.Thread(target=foo,args=(3,)) t1.start() #启动线程t1 #创建一个线程实例t2,bar为这个线程要运行的函数 t2=threading.Thread(target=bar,args=(5,)) t2.start() #启动线程t2 print("ending") s2=time.time() print("cost time:",s2-s1)
在这段程序里，一个函数会先休眠几秒钟，然后再打印一句话，第二个函数也是先休眠几秒钟，然后打印一句话。
接着程序会实例化两个线程，并调用两个函数来执行，最后会打印程序问总共执行了多少时间
程序运行结果如下：
ending cost time: 0.002000093460083008 foo func: 3 bar func: 5程序会先运行父线程，打印"ending",然后打印程序执行父线程的时间，最后才会运行子线程
1.2 通过thread类来继承式创建 import threading import time # 定义MyThread类，其继承自threading.Thread这个父类 class MyThread(threading.Thread): def __init__(self): threading.Thread.__init__(self) def run(self): print("ok") time.sleep(2) print("end t1") # 对类进行实例化 t1=MyThread() # 启动线程 t1.start() print("ending") 1.3 Thread类的一些常用方法****1.3.1 join():在子线程完成之前，主线程将一直被阻塞****
线程的join方法必须在子线程的start方法之后定义在第一个例子中加入两行代码，如下：
import threading import time def foo(n): time.sleep(n) print("foo func:",n) def bar(n): time.sleep(n) print("bar func:",n) s1=time.time() t1=threading.Thread(target=foo,args=(3,)) t1.start() t2=threading.Thread(target=bar,args=(5,)) t2.start() t1.join() # 阻塞t1线程 t2.join() # 阻塞t2线程 print("ending") s2=time.time() print("cost time:",s2-s1)再次执行程序，运行结果如下：
foo func: 3 bar func: 5 ending cost time: 5.002285957336426程序运行到子线程t1中的foo方法时会睡眠3秒钟，与此同时，子线程t2也在睡眠
等到子线程t1睡眠完成后，开始打印foo函数中的print语句，然后子线程t1执行完成
2秒钟之后，子线程t2睡眠完成，开始打印bar函数中的print语句，然后子线程t2也执行完成。
而在这之前，主线程一直处于阻塞状态。等到子线程执行完成之后主线程才会执行
****1.3.2 setDeamon(True)****
setDaemon方法作用是将进程声明为守护线程，必须在`start()`方法调用之前，如果不设置为守护线程，程序会被无限挂起
在程序执行过程中，执行一个主线程，主线程又创建一个子线程时，主线程和子线程会分别运行。
当主线程运行完成时，会检验子线程是否执行完成，如果子线程执行完成，则主线程会等待子线程完成后再退出。
但是有的时候只要主线程执行完成之后，不管子线程是否执行完成，都和主线程一起退出，这个就需要调用setDeamon方法了。
拿第一个例子来说吧，现在我想让子线程t1和t2随同主线程关闭，代码如下：
import threading import time def foo(n): print("foo start") time.sleep(n) print("foo end...") def bar(n): print("bar start") time.sleep(n) print("bar end...") s1 = time.time() t1 = threading.Thread(target=foo, args=(3,)) t1.setDaemon(True) t1.start() t2 = threading.Thread(target=bar, args=(5,)) t2.setDaemon(True) t2.start() print("ending") s2 = time.time() print("cost time:", s2 - s1)程序运行结果如下 ：
foo start bar start ending cost time: 0.003000020980834961可以看到，把t1和t2都声明为守护线程后，程序自上而下执行，先执行子线程t1中的foo方法，打印foo函数中的第一条打印语句，然后子线程t1进入到睡眠状态。
然后子线程t2执行，打印bar函数中的第一条print语句，然后子线程t2进入睡眠状态，程序切换到主线程运行
主线程打印完"ending"语句，发现子线程t1和t2已经被设置为守护线程，所以主线程不需要再等待两个子线程执行完成，而是立即结束，打印整个程序的执行时间。
整个程序就跟随主线程一起关闭了。
****1.3.3 子线程的一些其他方法****
isAlive() #判断一个线程是否是活动线程 getName() #返回线程的名字 setName() #设置线程的名字 import threading import time def foo(n): time.sleep(n) print("foo func:", n) def bar(n): time.sleep(n) print("bar func:", n) s1 = time.time() t1 = threading.Thread(target=foo, args=(3,)) t1.setDaemon(True) print("线程还未启动时，判断t1是否是活动的线程：", t1.isAlive()) # 线程还未启动，所以是False t1.start() # 启动线程 print("线程已启动时，判断t1是否是活动的线程：", t1.isAlive()) # 线程已启动，所以是True print("修改前的线程名为：",t1.getName()) # 获取线程名 t1.setName("t1") #设置线程名 print("修改后的线程名为：",t1.getName()) # 获取线程名 t1.join() print("线程执行完成时，判断t1是不否是活动的线程：", t1.isAlive()) # 线程已执行完成，所以是False # print(threading.activeCount()) print("ending") s2 = time.time() print("cost time:", s2 - s1)