概念
程序是静态的，程序运行起来后的代码+用到的资源（内存、摄像头、网络、硬盘等资源）叫进程，是操作系统分配资源的基本单元
进程的状态
实现多任务
import multiprocessing
import time
def test1():
while True:
print("----1----")
time.sleep(1)
def test2():
while True:
print("----2----")
time.sleep(1)
def main():
p1 = multiprocessing.Process(target=test1)
p2 = multiprocessing.Process(target=test2)
p1.start()
p2.start()
#print(p1.pid) #打印子进程的pid
#print(p2.pid)
if __name__ == '__main__':
main()
>>>----1----
>>>----2----
>>>----1----
>>>----2----
...
也可以继承multiprocessing.Process：
import multiprocessing
import time
class Process1(multiprocessing.Process):
def run(self):
while True:
print("----1----")
time.sleep(1)
class Process2(multiprocessing.Process):
def run(self):
while True:
print("----2----")
time.sleep(1)
def main():
p1 = Process1()
p2 = Process2()
p1.start()
p2.start()
if __name__ == '__main__':
main()
运行后有三个进程，主进程，子进程1，子进程2。
正常情况，子进程不会修改代码，只会修改内存中的数据，所以只要把资源（内存、摄像头、网络、硬盘等资源）拷贝过来即可，和主进程共享一份代码，节省开销：
如果子进程通过特殊方法修改了代码，这时子进程复制主进程的代码+资源：
和线程的区别
进程是代码+资源的总称，一个进程中的多任务就叫线程。
多个线程使用的是同一份资源，多个进程有各自的资源。
拿着进程的资源去运行的是线程。上图中的红箭头其实都是线程在运行
进程是资源分配的单位，线程是操作系统调度的单位
不同的场景下应用
1、对于io操作，线程优于进程，因为线程切换开销比进程小。GIL遇到io操作会主动释放。
2、对于消耗cpu的操作，进程优于线程，进程可以充分发挥多核的优势，能并行执行。线程由于GIL的限制，同一时刻只有一个线程在一个cpu上执行，线程是并发执行。
进程池概念
创建固定数量的进程（有任务才创建，会有个最大值），进程池循环利用里面的进程去执行多任务，避免了频繁创建进程销毁进程的开销
进程池使用
方式一
from multiprocessing import Pool
import os,time
def run1(msg):
print("%s开始执行，进程号是%d"%(msg,os.getpid()))
time.sleep(1)
if __name__ == "__main__":
po = Pool(2)#最多两个进程，现在不会创建，使用到的时候创建
for i in range(0, 6):#添加了6个任务，虽然超过了进程池大小，不会报错，会先存起来。空闲的子进程会从任务队列中取任务执行。
#添加任务到任务队列
result = po.apply_async(run1, (i,)) #apply_async()返回的是ApplyResult对象，可以通过get()获取返回值（该方法会阻塞主进程一直等待子进程的返回值），还有其他方法可以查看ApplyResult类
print('start')
po.close()#关闭进程池，关闭后po不会再接收新的请求
po.join()#等待po中所有子进程执行完成，必须放在close语句后面
print('end')
>>>start
>>>0开始执行，进程号是7404
>>>1开始执行，进程号是8040
>>>2开始执行，进程号是7404
>>>3开始执行，进程号是8040
>>>4开始执行，进程号是7404
>>>5开始执行，进程号是8040
>>>end
通过进程池创建的任务主进程不会等待子进程执行完成，如果没有调用join()，主进程执行完会直接结束，子进程的任务也跟着结束了。
通过multiprocessing.Process创建的子进程，主进程会等待子进程执行完成再退出。
方式二
from concurrent.futures import ProcessPoolExecutor,as_completed
import os,time
def run1(msg):
print("%s开始执行，进程号是%d"%(msg,os.getpid()))
time.sleep(1)
if __name__ == "__main__":
with ProcessPoolExecutor(2) as executor:
all_task = [executor.submit(run1,i) for i in range(0,6)]
for future in as_completed(all_task):
pass
print('end')
>>>0开始执行，进程号是6844
>>>1开始执行，进程号是804
>>>2开始执行，进程号是6844
>>>3开始执行，进程号是804
>>>4开始执行，进程号是6844
>>>5开始执行，进程号是804
>>>end
进程间通信
1、使用队列：
from multiprocessing import Queue
q = Queue(3) #初始化Queue对象，最多可接收三条put消息
q.put(1)
q.put('abc')
print(q.full())
q.put(['a','b','c'])
print(q.full())
try:
q.put_nowait('test') #q.put('test')，如果队列已满，会阻塞，不会像put_nowait()一样抛异常
except:
print('消息队列已满，现有消息数量：%s'%q.qsize())
if not q.empty():
for i in range(q.qsize()):
print(q.get_nowait()) #q.get()如果队列为空，会阻塞，不会像get_nowait()一样抛异常
多进程下不支持使用from queue import Queue，会抛异常：TypeError: can't pickle _thread.lock objects
multiprocessing .Queue作为中间介质：
import multiprocessing
def download_data(q):
data = [1,2,3,4]
#向队列中写入数据
for temp in data:
q.put(temp)
def deal_data(q):
#从队列中获取数据
resList = list()
while True:
data = q.get()
resList.append(data)
if q.empty():
break
print(resList)
def main():
#1、创建一个队列
q = multiprocessing.Queue()
#2、创建多个进程，将队列的引用传递过去
p1 = multiprocessing.Process(target=download_data,args=(q,))
p2 = multiprocessing.Process(target=deal_data,args=(q,))
p1.start()
p2.start()
if __name__ == "__main__":
main()
>>>[1,2,3,4]
如果在主进程中创建列表，通过共享变量的方式传递给子进程可以实现数据共享吗？
def addData1(tmp_list):
tmp_list.append(1)
print('进程1',tmp_list)
def addData2(tmp_list):
tmp_list.append(2)
print('进程2',tmp_list)
def main():
tmp_list = []
p1 = multiprocessing.Process(target=addData1,args=(tmp_list,))
p2 = multiprocessing.Process(target=addData2,args=(tmp_list,))
p1.start()
p2.start()
time.sleep(2)
print('主进程',tmp_list)
if __name__ == "__main__":
main()
>>>进程1 [1]
>>>进程2 [2]
>>>主进程 []
前面说过一般情况下，多进程共用一份代码，子进程拷贝主进程资源，各自独立
子进程中tmp_list = [],相当于各自拿同一份代码在执行，互不影响
multiprocessing .Queue在进程池中失效
下面的代码在进程池中使用了多进程的队列，没有输出结果
import multiprocessing
def download_data(q):
data = [1,2,3,4]
#向队列中写入数据
for temp in data:
q.put(temp)
def deal_data(q):
#从队列中获取数据
resList = list()
while True:
data = q.get()
resList.append(data)
if q.empty():
break
print(resList)
def main():
q = multiprocessing.Queue()
po = multiprocessing.Pool(2)
po.apply_async(download_data, (q,))
po.apply_async(deal_data, (q,))
po.close()
po.join()
if __name__ == "__main__":
main()
q = multiprocessing.Queue()修改成q = multiprocessing.Manager().Queue()后可以正常输出
2、使用管道
pipe适用于只有两个进程通信的场景，性能高于queue
from multiprocessing import Process,Pipe
def download_data(pipe):
pipe.send([1,2,3])
def deal_data(q):
print(q.recv())
def main():
recv_pipe,send_pipe = Pipe()
p1 = Process(target=download_data,args=(send_pipe,))
p2 = Process(target=deal_data,args=(recv_pipe,))
p1.start()
p2.start()
if __name__ == "__main__":
main()
>>>[1,2,3]
3、Manager()提供的共享变量
将上面的tmp_list修改成multiprocessing.Manager().list()，可以定义一个进程间共享的list()变量。Manager()还提供了其他的数据类型。
import multiprocessing
import time
def addData1(tmp_list):
tmp_list.append(1)
print('进程1',tmp_list)
def addData2(tmp_list):
tmp_list.append(2)
print('进程2',tmp_list)
def main():
tmp_list = multiprocessing.Manager().list()
p1 = multiprocessing.Process(target=addData1,args=(tmp_list,))
p2 = multiprocessing.Process(target=addData2,args=(tmp_list,))
p1.start()
p2.start()
time.sleep(2)
print('主进程',tmp_list)
if __name__ == "__main__":
main()
>>>进程2 [2]
>>>进程1 [2, 1]
>>>主进程 [2, 1]
网友评论