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()