一、基本概念
程序：程序可以理解成是一系列的指令集，程序是静态。
进程：当程序运行时，会创建一个进程。
线程：进程基本执行单元，一个进程至少有一个线程。
进程和线程之间的关系：
一个线程只属于一个进程，一个进程中可以包含很多线程，只有一个主线程。
进程资源、线程的资源对比：
进程具有独立的空间和系统资源。
线程没有独立的空间和系统资源，同一个进程下的多个线程共享该进程中的资源的。
问题：多线程中对于共享资源修改的问题-----多线程同步问题----线程不安全。
二、多线程
单核cpu下：并行：宏观，微观上来看，仍然是串行
多核cpu：真正并行
计算机cpu执行，IO操作场合
计算密集型:不适合单核cpu多线程
io密集型：适合单核cpu的多线程
多线程的缺点
（1）线程本身也是程序，也是需要占内存，线程越多，占用的内存就越多 。
（2）多线程之间的调用需要协调管理，需要cpu进行线程的跟踪
（3）重要：多线程之间对共享资源的访问有影响，必须解决线程共享资源的问题，否则会导致数据的不一致。
三、线程的创建
三种方式
- 使用threading模块创建，通过指定target和args参数，创建线程
- 使用Thread类，重写run方法
- 使用线程池（高阶）
方式1
import time
import threading
# def mission(end):
# for i in range(end):
# print(i)
# time.sleep(0.5)
# target函数的名字
# args参数，必须使用元组传递
# t1=threading.Thread(target=mission,args=(10,))
# t2=threading.Thread(target=mission,args=(10,))
#激活线程，不是执行线程，把当前线程任务加入到cpu的任务执行列表中
等待cpu分配时间片来执行
# t1.start()
# t2.start()
方式2
# # class MyThread(threading.Thread):
# def __init__(self,end):
# self.end=end
# super().__init__()
# def run(self):
# for i in range(self.end):
# print(i)
# t1=MyThread(10)
# t2=MyThread(10)
# t1.run()------先执行完----任务顺序执行
# t2.run()------后执行完----任务顺序执行
# t1.start()-----将任务交给CPU，任务可以交替执行
# t2.start()-----将任务交给CPU，任务可以交替执行
当需要创建很多个执行相同方法的线程对象时，建议使用继承Thread类，重写run方法，run方法才是真正执行任务函数的方法。
start方法和run方法有什么区别？
start: 激活线程，不代表真正的执行，使得线程处于就绪状态，加入cpu执行任务列表。
run：真正执行任务的函数。
方式3
线程池创建线程的两种方式:
进程池下的线程池、第三方安装包threadpool。
进程池下的线程池
(1)multiprocessing.pool
from multiprocessing.pool import ThreadPool
同步apply
异步
# def work(i):
# print("第{}个线程开始".format(i))
# time.sleep(1)
#
# if __name__=="__main__":
# print("主程序执行开始")
# pool=ThreadPool(3)
# for i in range(3):
# pool.apply_async(work,args=(i,))
# args为一个元组,当为单个元素时，元素后面加“，”。
# pool.close()
# pool.join()
# print("主程序执行完毕")
def sum2(b1,b2):
pool = ThreadPool(3)
for i in range(10):
pool.apply_async(sum,args=(0,b1))
pool.apply_async(sum,args=(0,b2))
pool.close()
pool.join()
# if __name__=="__main__":
# start=time.time()
# # sum2(10000000,20000000)
# sum2(10,20)
# end=time.time()
# print("执行的时间{}".format(end-start))
第三方安装包threadpool
安装第三方包 pip install 包名
import threadpool
（1）引入threadpool模块。
（2）定义线程函数。
（3）创建线程池threadpool.ThreadPool(maxsize)。
（4）创建需要线程池处理的任务列表
requests= threadpool.makeRequests()。
（5）将创建的多个任务put到线程池中。线程池对象.putRequests(任务)。
（6）等到所有任务处理完毕。线程池对象.wait()----先用close再用join效果类似。
makeRequests（任务，参数列表）
参数列表：[((参数1，参数2),(字典型参数1，字典型参数2))]
def work(i):
print("第{}线程开始执行".format(i))
time.sleep(1)
print("第{}线程执行结束".format(i))
# if __name__=="__main__":
# pool= threadpool.ThreadPool(5)
# requests=threadpool.makeRequests(work,args_list=range(3))
# for r in requests:
# pool.putRequest(r) # 类似执行start
#
# pool.wait()
# print("主程序执行完毕")
def sum3(b1,b2):
pool=threadpool.ThreadPool(5)
asl=[((0,b1),None),((0,b2),None)]
requests=threadpool.makeRequests(sum,args_list=asl)
for i in requests:
pool.putRequest(i)
pool.wait()
if __name__=="__main__":
start=time.time()
# sum3(10000000,20000000)
sum3(10,20)
end=time.time()
print("执行的时间{}".format(end-start))
四、线程的生命周期
1. 新建：（人的出生）： 创建线程对象，没有执行能力。
2. 就绪：（等待就业）： 调用了start方法，不是马上执行，把执行权利交给cpu。
3. 运行：（入职工作）： 执行线程的任务，获得了cpu的时间片，cpu在一个线程运行的时候，是可能将时间片分配给其他线程。
4. 阻塞：（生病） ： 处于等待的过程中（调用sleep），cpu不会将时间片分给阻塞状态的进程。
5. 死亡：（死亡） ：run方法执行完毕，run方法中抛出没有捕获的异常。