Python多进程

在Python中如果想创建多进程需要用到multiprrocessing中的Prrocess方法。

在进程之间全局变量是不共享的，如果要对进程的全局变量进行使用的话就需要用到multiprrocessing的Queue方法

首先我们先创建一个多进程

import time
from multiprocessing import Process
# 进程之间全局变量不共享


def work_1():
    for i in range(10):
        print('任务1')
        time.sleep(0.5)


def work_2():
    for i in range(10):
        print('任务2')
        time.sleep(0.5)


# 进程执行的时候不加main 为什么会报错：
# 在执行过程中相当于在另外一个py文件中导入这个模块并运行函数，由于是导入模块所以
# 创建多进程的代码也会被导入，然后就又去开了线程，陷入无限递归的状态
if __name__ == '__main__':
    # 创建两个进程
    p1 = Process(target=work_1)
    p2 = Process(target=work_2)
    p1.start()
    p2.start()

看过我之前写的关于线程的那么上面这段代码一定可以看懂，如果不明白可以回去看看关于线程的。

我们在多进程之间通讯需要用到队列，但是这个队列不是Queue.queue() 而是multiprrocessing中的Queue

queue.Queue 是进程内非阻塞队列

multiprocessing.Queue 是跨进程通信队列

import requests
from multiprocessing import Process, Queue

def work_1(q):
    while q.qsize() > 0:
        url = q.get()
        requests.get(url)
        print('任务1')


def work_2(q):
    while q.qsize() > 0:
        url = q.get()
        requests.get(url)
        print('任务2')


if __name__ == '__main__':
    q = Queue()
    for i in range(10):
        q.put('http://localhost:3000/login')
# 将q 这个实例化对象当作参数传入函数中（不同的进程中），可以实现多进程共享变量，把这个队列放到一个公共区间内
    p1 = Process(target=work_1, args=(q,))
    p2 = Process(target=work_2, args=(q,))
    p1.start()
    p2.start()

下面来聊一聊进程池：

Pool可以提供指定数量的进程供用户调用，当有新的请求提交到pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到规定最大值，那么该请求就会等待，直到池中有进程结束，才会创建新的进程来它。

import requests
from multiprocessing import Pool, Manager  # 进程池Pool    Manager().Queue()  # 进程池中的队列
import time
import os  # 查看进程的pid
# a = Manager().Queue()  # 进程池中的队列


def work(q):
    # 判断队列是否有任务
    while q.qsize() > 0:
        # 获取任务
        url = q.get()
        requests.get(url)
        print('任务1{}'.format(os.getpid()))


if __name__ == '__main__':
    # 进程池中的队列
    q = Manager().Queue()
    for i in range(10):
        # 增加任务
        q.put('http://localhost:3000/login')
    # 创建进程池 最大进程数为3
    p = Pool(3)
    for i in range(10): 
        # 开启进程执行任务  在进程池中，初始化几个进程，轮询执行任务，当一个任务执行完毕后这个进程会去执行另一个任务，直到所有任务完成
        if q.qsize() > 0:
　　　　　　　　# 每次循环将会用空闲出来的子进程去调用目标
            p.apply_async(work, args=(q,))  # 异步的效率,也就是池中的进程一次性都去执行任务. 进程中有3个进程，一下就处理3个任务，接下来哪个进程处理完任务了，就马上去接收下一个任务

    p.close()  # 进程池使用完毕一定要关闭进程池:停止往进程池中添加新的任务
    p.join()  # 等待po中所有子进程执行完成，必须在close之后  等待线程池中的所有任务都执行完了之后再往下执行
# 异步处理任务时 : 必须要加上close和join. 进程池的所有进程都是守护进程(主进程代码执行结束,守护进程就结束).