python 多进程
多进程
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 time
def 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 time
def 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 multiprocessing
def 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 += 100
print(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 time
num = 100
lst = []
def main():
p1 = multiprocessing.Process(target=demo1)
p2 = multiprocessing.Process(target=demo2)
p1.start()
p2.start()
def demo1():
global num
num += 100
print(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(): #判断队列是否为空
break
print(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()