多进程 

Process类start() 来启动一个进程，此时进程处于可运行状态，但是还没运行，一旦得到cpu时间片，就开始执行run（）方法。

调用run() 方法，此时程序中只有主线程一个现场，程序执行路径还是只有一条

import multiprocessing
import time
def download():print('开始下载')for i in range(3):print('-----1------')time.sleep(1)def upload():print('上传完毕')for i in range(3):print('-----2------')time.sleep(1)def main():#queue = multiprocessing.Queue()    #实例化队列process1 = multiprocessing.Process(target=upload)process2 = multiprocessing.Process(target=download)# process1.run()# process2.run()process1.start()process2.start()if __name__ == '__main__':main()

python函数os.getpid可以获取当前进程的PID，
python函数os.getppid 可以获取当前进程的主进程的PPID

import os
from multiprocessing import Process
import timedef main():p1 = Process(target=demo1)p2 = Process(target=demo2)p1.start()p2.start()print('父进程')print('当前进程 PID：', os.getpid(), '父进程 PPID', os.getppid())p1.join()p2.join()def demo1():print('当前进程1')time.sleep(2)print('当前进程1 PID：',os.getpid(),'父进程 PPID',os.getppid())def demo2():print('当前进程2')print('当前进程2 PID：',os.getpid(),'父进程 PPID',os.getppid())time.sleep(20)if __name__ == '__main__':main()

进程池

当创建的子进程数量不多时，可以直接利用mutiprocessing中的Process动态生成多个进程。但是如果上百个目标，手动的去创建费劲，此时可以利用multiprocessing提供的pool方法。

初始化进程池的时候，需要指定最大进程数，当有新的请求提交到Pool中时，如果进程池没有满，那么就会直接创建，如果满了则需要等待池中的进程结束在进行分配。

import multiprocessing
import os
import timedef worker(msg):start_time = time.time()print(msg,f'开始运行，线程号{os.getpid()}')time.sleep(30)stop_time = time.time()print(msg, f'结束运行，所用时间{stop_time-start_time}')def main():#新建进程池pool = multiprocessing.Pool(3)for i in range(5):#开始执行任务pool.apply_async(worker,args=(i,))#关闭线程池，线程池不接接受新的任务#主进程阻塞，子进程不会结束print('主进程开始执行')pool.close()pool.join()print('主进程结束')
if __name__ == '__main__':main()

进程池之间通信

import multiprocessingdef main():#1.创建队列通信queue = multiprocessing.Manager().Queue()#2.创建进程池pool = multiprocessing.Pool(3)#3.给进程池添加任务，任务函数的参数为队列通信pool.apply_async(demo1,args=(queue,))pool.apply_async(demo2, args=(queue,))pool.close()pool.join()def demo1(queue):queue.put('11')queue.put('22')print('-----1------')def demo2(queue):#l = queue.get()print('-----2------')print(queue.get())print(queue.get())if __name__ == '__main__':main()

多进程之间共享全局变量 

线程之间是可以正常共享全局变量的，因为是共用同一片空间的，而进程之间所使用的是不同的内存空间
所以线程之间可以共享全局变量，因为共用一片空间
不同进程使用不同的空间，所以使用的资源本质上是不同的，所以一片空间上的变量变化了不会影响另一个空间的资源变化。

import threading
import time
num = 100
def demo1():global num# time.sleep(1)num += 100print(f'----demo1---num={num}')def demo2():print(f'------demo2-----num={num}')def main():t1 = threading.Thread(target=demo1)t2 = threading.Thread(target=demo2)t1.start()t2.start()
if __name__ == '__main__':main()

import multiprocessing
import timenum = 100
lst = []def main():p1 = multiprocessing.Process(target=demo1)p2 = multiprocessing.Process(target=demo2)p1.start()p2.start()def demo1():global numnum += 100print(f'-----demo1----{num}')lst.append(num)print(lst)#time.sleep(1)def demo2():time.sleep(1)print(f'-----demo2----{num}')print(lst)if __name__ == '__main__':main()

import multiprocessing
from multiprocessing import Queue
def download(q):lst = [1,2,3]for i in lst:q.put(i)print('添加完毕')def manage_data(q):#将队列的元素取出来，存到新的列表中man_data = list()while True:data = q.get()print(data)man_data.append(data)if q.empty():  #判断队列是否为空breakprint(man_data)def main():q = Queue()p1 = multiprocessing.Process(target=download,args=(q,))p2 = multiprocessing.Process(target=manage_data,args=(q,))p1.start()p2.start()if __name__=='__main__':main()