一，线程与进程之间的关系：（从知乎上看到的）
一个必须知道的事实：执行一段程序代码，实现一个功能的过程介绍 ，当得到CPU的时候，相关的资源必须也已经就位，就是显卡啊，GPS啊什么的必须就位，然后CPU开始执行。这里除了CPU以外所有的就构成了这个程序的执行环境，也就是我们所定义的程序上下文。当这个程序执行完了，或者分配给他的CPU执行时间用完了，那它就要被切换出去，等待下一次CPU的临幸。在被切换出去的最后一步工作就是保存程序上下文，因为这个是下次他被CPU临幸的运行环境，必须保存。
串联起来的事实：前面讲过在CPU看来所有的任务都是一个一个的轮流执行的，具体的轮流方法就是：先加载程序A的上下文，然后开始执行A，保存程序A的上下文，调入下一个要执行的程序B的程序上下文，然后开始执行B,保存程序B的上下文。。。。========= 重要的东西出现了========
进程和线程就是这样的背景出来的，两个名词不过是对应的CPU时间段的描述，名词就是这样的功能。
- 进程就是包换上下文切换的程序执行时间总和 = CPU加载上下文+CPU执行+CPU保存上下文
线程是什么呢？
进程的颗粒度太大，每次都要有上下的调入，保存，调出。如果我们把进程比喻为一个运行在电脑上的软件，那么一个软件的执行不可能是一条逻辑执行的，必定有多个分支和多个程序段，就好比要实现程序A，实际分成 a，b，c等多个块组合而成。那么这里具体的执行就可能变成：
程序A得到CPU =》CPU加载上下文，开始执行程序A的a小段，然后执行A的b小段，然后再执行A的c小段，最后CPU保存A的上下文。
这里a，b，c的执行是共享了A的上下文，CPU在执行的时候没有进行上下文切换的。这里的a，b，c就是线程，也就是说线程是共享了进程的上下文环境，的更为细小的CPU时间段。到此全文结束，再一个总结：
进程和线程都是一个时间段的描述，是CPU工作时间段的描述，不过是颗粒大小不同，一个进程中包含了多个线程，在一个时间段内，只能有一个线程占用cpu，cpu不能同时执行多个任务，只不过cpu运行速度太快，我们感知不到，就以为，线程可以同时执行，对于多核cpu，实际也同一个时间段也只有一个cpu在工作
import threading import time def axb(name): time.sleep(1) print(name) for i in range(10): t=threading.Thread(target=axb,args=(i,)) ##args 定义的是一个元组，必须加逗号，才能识别为元组 t.start() print('game over')
三，线程等待
线程等待，多线程在运行的时候，每个线程都是独立运行的，不受其他的线程干扰，如果想在哪个线程运行完之后，再做其他操作的话，就得等待它完成，那怎么等待呢，使用join，等待线程结束
import threading
import time
def run():
print('qqq')
time.sleep(1)
print('done!')
lis = []
for i in range(5):
t = threading.Thread(target=run)
lis.append(t)
t.start()
for t in lis:
t.join() #主线程等待子线程执行完
print('over')
四，获取多线程时执行结果的返回值
例如我们做接口测试时候，需要获取每个线程执行时间
import threading import time import requests run_times = [] #怎么获取到多线程执行的函数里面的返回值 def blog(): stat_time = time.time() r = requests.get('http://www.nnzhp.cn/').text end_time = time.time() run_time = end_time-stat_time run_times.append(run_time) objs = [] for i in range(100): t = threading.Thread(target=blog()) t.start() objs.append(t) for obj in objs: obj.join()#join中可以设置timeout时间，主线程等待时间超过timeout时间后就会继续执行，不再等待 avg = sum(run_times)/len(run_times) print('平均响应时间是',avg)
五，守护线程：就相当于你是一个国王（非守护线程），然后你有很多仆人（守护线程），这些仆人都是为你服务的，一但你死了，那么你的仆人都给你陪葬。
主线程死掉了（执行完了），那么不管子线程运行完否，都一起结束
import time import threading def test(): time.sleep(2) print('hhhh') for i in range(5): t=threading.Thread(target=test) t.setDaemon(True)#设置子线程为守护线程 t.start()
程序执行结果不会打印 hhhh，因为主线程执行完的时候，子线程还没执行完，所以，主线程死掉了，守护子线程跟着消亡了
六、锁：线程锁就是，很多线程一起在操作一个数据的时候，可能会有问题，就要把这个数据加个锁，同一时间只能有一个线程操作这个数据。
import threading from threading import Lock num = 0 lock = Lock() # 申请一把锁 def run(): global num lock.acquire() # 加锁 num += 1 lock.release() # 解锁 lis = [] for i in range(5): t = threading.Thread(target=run) t.start() lis.append(t) for t in lis: t.join() print('over', num)
七，多进程：Python里面的多线程，是不能利用多核CPU的，如果想利用多核CPU的话，就得使用多进程，python中多进程使用multiprocessing模块。
from multiprocessing import Process import time def test(i): time.sleep(1) print(i) if __name__=='__main__': for i in range(10): p=Process(target=test,args=(i,)) p.start()
threading与实例对象提供了几个方法可以让我们更直观的学习线程。
threading.active_count() # 返回当前运行的线程个数 threading.enumerate() # 返回当前运行中的线程list threading.current_thread() # 返回当前的线程变量 t1.start() # 启动线程 t1.is_alive() # 判断线程是否在运行 运行指启动后、终止前。 t1.getName() # 获取线程名 t1.setName('填写更改后的名称') # 对线程进行命名 t1.setDaemon(True) # 设置守护线程 t1.isDaemon() # 判断是否是守护线程 t1.join(timeout=20) # 阻塞当前上下文环境的线程，直到调用此方法的线程终止或到达指定的timeout（可选参数）
