线程池的原理：
线程池是预先创建线程的一种技术。线程池在还没有任务到来之前，
创建一定数量的线程，放入空闲队列中。这些线程都是处于睡眠状态，
即均为启动，不消耗CPU，而只是占用较小的内存空间。当请求到来之后，
缓冲池给这次请求分配一个空闲线程，把请求传入此线程中运行，进行处理。
当预先创建的线程都处于运行状态，即预制线程不够，线程池可以自由创建一定数量的新线程，
用于处理更多的请求。当系统比较闲的时候，也可以通过移除一部分一直处于停用状态的线程。
进程间的通信原理：
OS提供了沟通的媒介供进程之间“对话”用。既然要沟通，如同人类社会的沟通一样，
沟通要付出时间和金钱，计算机中也一样，必然有沟通需要付出的成本。
出于所解决问题的特性，OS提供了多种沟通的方式，每种方式的沟通成本也不尽相同，
使用成本和沟通效率也有所不同。我们经常听到的 管道、消息队列、共享内存都是OS提供的供进程之间对话的方式。
Process（target， name， args， kwargs）
name：
给进程取名字
默认为Process-1，Process-2.....
p.name 查看进程名
args：
以元组的形式给target函数传参
kwargs：
以字典的形式给对应键的值传参
进程对象的其他常用属性方法：
p.name p.start() p.join()
p.pid:
获取创建进程的pid号
p.is_alive():
判断进程是处于alive状态
p.daemon:
默认为Flase 如果设置为True 主进程结束时杀死所有子进程
daemon属性一定要在start（）前设置
设置daemon为True 一般不需要加join（）
daemon不是真正意义上的守护进程
守护进程：
不受终端控制
后台自动运行
生命周期长
多进程copy一个文件拆分为两个进行保存
import os from multiprocessing import Process from time import sleep #获取文件的大小 size = os.path.getsize("./timg.jpeg") # 获取文件的字节数 # f = open("timg.jpeg",'rb') #复制前半部分 def copy1(img): f = open(img,'rb') # 二进制读取要复制的文件 n = size // 2 fw = open('1.jpeg','wb') # 二进制创建文件 while True: if n < 1024: # 判断文件大小是否大于1024字节 如果小于则直接读取写入 data = f.read(n) fw.write(data) break data = f.read(1024) # 否则每次循环读取1024字节并写入 fw.write(data) n -= 1024 f.close() fw.close() #复制后半部分 def copy2(img): f = open(img,'rb') # 读取文件必须要每次读取 如果在父进程中打开文件流对像 # 子进程会通同时调用一个文件流对像 由于文件流对象特性会记录游标 # 如若先执行后半部复制这前半部会导致读取不到数据 fw = open('2.jpeg','wb') f.seek(size // 2,0) while True: data = f.read(1024) if not data: break fw.write(data) fw.close() f.close() p1 = Process(target = copy1,args = ('timg.jpeg',)) # 创建子进程并让子进程分别同时复制 p2 = Process(target = copy2,args = ('timg.jpeg',)) p1.start() p2.start() p1.join() p2.join()
os.path.getsize('./1.txt')：
读取文件大小
注：
1.如果多个子进程拷贝同一个父进程的对象则多个子进程
使用的是同一个对象（如文件队形，套接字，队列，管道。。。）
2.如果在创建子进程后单独创建的对象，则多个子进程各不相同
创建子自定义进程类
1.编写类继承Process
2.在自定义类中加载父类__init__以获取父类属性，
同时可以自定义新的属性
3.重写run方法 在调用start时自动执行该方法
示例：
from multiprocessing import Process import time class ClockProcess(Process): def __init__(self,value): #调用父类init super().__init__() self.value = value #重写run方法 def run(self): for i in range(5): time.sleep(self.value) print("The time is {}".format(time.ctime())) p = ClockProcess(2) #自动执行run p.start() p.join()
进程的缺点：
进程在创建和销毁的过程中消耗的资源相对较多
进程池技术：
产生原因：
如果有大量的任务需要多进程完成，而调用周期比较短且需要频繁创建
此时可能产生大量进程频繁创建销毁的情况 消耗计算机资源较大
使用方法：
1.创建进程池，在池内放入适当数量的进程
2.将事件封装成函数。放入到进程池
3.事件不断运行，直到所有放入进程池事件运行完成
4.关闭进程池，回收进程
from multiprocessing import pool
pool（Process）
功能：创建进程池对象
参数：进程数量
返回值：进程池对象
pool = pool（）
pool.apply_async(fun, args, kwds)（异步执行）
功能：将事件放入进程池内
参数：
fun：要执行的函数
args：以元组形式为fun传参
kwds：以字典形式为fun传参
返回值：
返回一个事件对象，通过p.get（）函数可以获取fun的返回值
pool.close():
功能：
关闭进程池，无法再加入新的事件，并等待已有事件结束执行
pool.join()
功能：回收进程池
pool.apply(fun, args, kwds)（同步执行）
功能：将事件放入进程池内
参数：
fun：要执行的函数
args：以元组形式为fun传参
kwds：以字典形式为fun传参
没有返回值
示例:
from multiprocessing import Pool from time import sleep,ctime def worker(msg): sleep(2) print(msg) return ctime() #创建进程池对象 pool = Pool(processes = 4) result = [] for i in range(10): msg = "hello %d"%i #将事件放入进程池 r = pool.apply_async(func = worker,args = (msg,)) result.append(r) #同步执行 # pool.apply(func = worker,args = (msg,)) #关闭进程池 pool.close() #回收 pool.join() #获取事件函数返回值 for i in result: print(i.get())
pool.map（func， iter）
功能：
将要执行的事件放入进程池
参数：
func 要执行的函数
iter 可迭代对象
示例：
from multiprocessing import Pool import time def fun(n): time.sleep(1) print("执行 pool map事件",n) return n ** 2 pool = Pool(4) #在进程池放入6个事件 r = pool.map(fun,range(6)) # map高阶函数 fun和iter执行6次 print("返回值列表:",r) pool.close() pool.join()
进程间的通信（IPC）
由于进程空间独立，资源无法共享，
此时在进程间通讯就需要专门的通讯方法
通信方法：
管道、消息队列、共享内存
信号、信号量、套接字
管道通信：
在内存中开辟一块内存空间，形成管道结构
多个进程使用同一个管道，即可通过对管道的读写操作进行通讯
multiprocessing --> Pipe
fd1，fd2 = Pipe(duplex=True)
功能：创建管道
参数：
默认表示双向管道
如果设置为False则为单向管道
返回值：
俩个管道对象的，分别表示管道的两端
如果是双向管道则均可读写
如果是单向管道则fd1只读，fd2只写
fd.recv（）
功能：从管道读取信息
返回值：读取到的内容
当管道为空则阻塞
fd.send（data）
功能：向管道写入内容
参数：要写入的内容
当管道满时会阻塞
可以写入几乎所有Python所有数据类型
队列通信：
在内存中开辟队列结构空间，多个进程可见，
多个进程操作同一个队列对象可以实现消息存取工作
在取出时必须按照存入顺序取出（先进先出）
q = Queue（maxsize=0）
功能：
创建队列对象
参数：
maxsize 默认表示根据系统分配空间储存消息
如果传入一个正整数则表示最多存放多少条消息
返回值：队列对象
q.put（data,[block,timeout]）
功能：向队列存入消息
参数：
data：存入消息（支持Python数据类型）
block：默认True表示当队满时阻塞
设置为False 则为非阻塞
timeout：当block为True是表示超时检测
data = q.get([block,timeout])
功能：取出消息
参数：
block：设置为True 当队列为空时阻塞
设置为False表示非阻塞
timeout：
当block为True是表示超时检测
q.full（） 判断队列是否为满
q.empty() 判断队列是否为空
q.qsize() 获取队列中消息的数量
q.close() 关闭队列
共享内存通信：
在内存中开辟一段空间存储数据对多个进程可见，
每次写入共享内存中的内容都会覆盖之前内容
对内存的读操作不会改变内存中的内容
form multiprocessing import Value，Array
shm = Value（ctype，obj）
功能：共享内存共享空间
参数：
ctype：字符串 要转换的c语言的数据类型
obj：共享内存的初始数据
返回值：返回共享内存对象
shm.value：
表示共享内存的值
示例：
from multiprocessing import Process,Value import time import random #创建共享内存 money = Value('i',6000) #存钱 def deposite(): for i in range(100): time.sleep(0.05) #对value的修改就是对共享内存的修改 money.value += random.randint(1,200) #花销 def withdraw(): for i in range(100): time.sleep(0.04) #对value的修改就是对共享内存的修改 money.value -= random.randint(1,200) d = Process(target = deposite) w = Process(target = withdraw) d.start() w.start() d.join() w.join() print(money.value)
shm = Array（ctype，obj）
功能：
开辟共享内存空间
参数：
ctype：要转换的数据类型
obj：
要存入共享内容的的数据（结构化数据）
列表、字符串 表示要存入得内容
要求数据结构内的类型相同
整数 表示要开辟几个单元的空间
返回值：
返回共享内存对象 可迭代对象
示例：
from multiprocessing import Process,Array import time #创建共享内存 shm = Array('c',b"hello") #字符类型要求是bytes #开辟5个整形单元的共享内存空间 # shm = Array('i',5) def fun(): for i in shm: print(i) shm[0] = b"H" p = Process(target = fun) p.start() p.join() print(shm.value) #从首地址打印字符串 # for i in shm: # print(i)
三种进程间通信区别：
管道通信： 消息队列： 共享内存：
开辟空间： 内存 内存 内存
读写方式： 两端读写 先进先出 每次覆盖上次内容
单向/双向
效率： 一般 一般 较快
应用： 多用于父子进程 应用灵活广泛 复杂，需要同步互斥
