> 文档中心 > 100天精通Python(进阶篇)——第38天:多进程【文末送书三本】

100天精通Python(进阶篇)——第38天:多进程【文末送书三本】

在这里插入图片描述

文章目录

  • 每篇前言
  • 一、什么是多进程
    • 1. 进程
    • 2. 进程的状态
  • 二、进程的创建-multiprocessing
    • 1. Process类语法说明
    • 2. 2个while循环一起执行
    • 3. 进程pid
    • 4. 给子进程指定的函数传递参数
    • 5. 进程间不同享全局变量
  • 三、进程间同步-Queue
    • 1. Queue类语法说明
    • 2. Queue的使用
    • 3. Queue实例
  • 四、进程间同步-Lock
  • 五、进程池Pool
    • 1. Pool类语法说明
    • 2. Pool实例
    • 3. 进程池中的Queue
  • 六、进程、线程对比
    • 1. 功能
    • 2. 区别
    • 3. 优缺点
  • 如何让学习变得更加高效呢?
  • 🎉参与抽粉丝送书啦

每篇前言

  • 🏆🏆作者介绍:Python领域优质创作者、华为云享专家、阿里云专家博主、2021年CSDN博客新星Top6

  • 🔥🔥本文已收录于Python全栈系列专栏:《100天精通Python从入门到就业》
  • 📝​📝​此专栏文章是专门针对Python零基础小白所准备的一套完整教学,从0到100的不断进阶深入的学习,各知识点环环相扣
  • 🎉🎉订阅专栏后续可以阅读Python从入门到就业100篇文章还可私聊进两百人Python全栈交流群(手把手教学,问题解答); 进群可领取80GPython全栈教程视频 + 300本计算机书籍:基础、Web、爬虫、数据分析、可视化、机器学习、深度学习、人工智能、算法、面试题等。
  • 🚀🚀加入我一起学习进步,一个人可以走的很快,一群人才能走的更远!

在这里插入图片描述
在这里插入图片描述

一、什么是多进程?

1. 进程

程序:例如xxx.py这是程序,是一个静态的

进程:一个程序运行起来后,代码+用到的资源 称之为进程,它是操作系统分配资源的基本单元。不仅可以通过线程完成多任务,进程也是可以的

2. 进程的状态

工作中,任务数往往大于cpu的核数,即一定有一些任务正在执行,而另外一些任务在等待cpu进行执行,因此导致了有了不同的状态
100天精通Python(进阶篇)——第38天:多进程【文末送书三本】

  • 就绪态:运行的条件都已经慢去,正在等在cpu执行
  • 执行态:cpu正在执行其功能
  • 等待态:等待某些条件满足,例如一个程序sleep了,此时就处于等待态

二、进程的创建-multiprocessing

1. Process类语法说明

multiprocessing 模块通过创建一个 Process 对象然后调用它的 start()方法来生成进程,Processthreading.Thread API 相同。

语法格式multiprocessing.Process(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)

参数说明

  • group:指定进程组,大多数情况下用不到
  • target:如果传递了函数的引用,可以任务这个子进程就执行这里的代码
  • name:给进程设定一个名字,可以不设定
  • args:给target指定的函数传递的参数,以元组的方式传递
  • kwargs:给target指定的函数传递命名参数

multiprocessing.Process 对象具有如下方法和属性:

方法名/属性 说明
run() 进程具体执行的方法
start() 启动子进程实例(创建子进程)
join([timeout]) 如果可选参数 timeout 是默认值 None,则将阻塞至调用 join() 方法的进程终止;如果 timeout 是一个正数,则最多会阻塞 timeout 秒
name 当前进程的别名,默认为Process-N,N为从1开始递增的整数
pid 当前进程的pid(进程号)
is_alive() 判断进程子进程是否还在活着
exitcode 子进程的退出代码
daemon 进程的守护标志,是一个布尔值。
authkey 进程的身份验证密钥。
sentinel 系统对象的数字句柄,当进程结束时将变为 ready。
terminate() 不管任务是否完成,立即终止子进程
kill() 与 terminate() 相同,但在 Unix 上使用 SIGKILL 信号。
close() 关闭 Process 对象,释放与之关联的所有资源

2. 2个while循环一起执行

# -*- coding:utf-8 -*-from multiprocessing import Processimport timedef run_proc():    """子进程要执行的代码"""    while True: print("----2----") time.sleep(1)if __name__=='__main__':    p = Process(target=run_proc)    p.start()    while True: print("----1----") time.sleep(1)

运行结果:
在这里插入图片描述
说明:创建子进程时,只需要传入一个执行函数和函数的参数,创建一个Process实例,用start()方法启动

3. 进程pid

# -*- coding:utf-8 -*-from multiprocessing import Processimport osimport timedef run_proc():    """子进程要执行的代码"""    print('子进程运行中,pid=%d...' % os.getpid())  # os.getpid获取当前进程的进程号    print('子进程将要结束...')if __name__ == '__main__':    print('父进程pid: %d' % os.getpid())  # os.getpid获取当前进程的进程号    p = Process(target=run_proc)    p.start()

运行结果:
在这里插入图片描述

4. 给子进程指定的函数传递参数

# -*- coding:utf-8 -*-from multiprocessing import Processimport osfrom time import sleepdef run_proc(name, age, **kwargs):    for i in range(10): print('子进程运行中,name= %s,age=%d ,pid=%d...' % (name, age, os.getpid())) print(kwargs) sleep(0.2)if __name__=='__main__':    p = Process(target=run_proc, args=('test',18), kwargs={"m":20})    p.start()    sleep(1)  # 1秒中之后,立即结束子进程    p.terminate()    p.join()

运行结果:
在这里插入图片描述

5. 进程间不同享全局变量

# -*- coding:utf-8 -*-from multiprocessing import Processimport osimport timenums = [11, 22]def work1():    """子进程要执行的代码"""    print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))    for i in range(3): nums.append(i) time.sleep(1) print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))def work2():    """子进程要执行的代码"""    print("in process2 pid=%d ,nums=%s" % (os.getpid(), nums))if __name__ == '__main__':    p1 = Process(target=work1)    p1.start()    p1.join()    p2 = Process(target=work2)    p2.start()

运行结果:

in process1 pid=11349 ,nums=[11, 22]in process1 pid=11349 ,nums=[11, 22, 0]in process1 pid=11349 ,nums=[11, 22, 0, 1]in process1 pid=11349 ,nums=[11, 22, 0, 1, 2]in process2 pid=11350 ,nums=[11, 22]

三、进程间同步-Queue

Process之间有时需要通信,操作系统提供了很多机制来实现进程间的通信。

1. Queue类语法说明

方法名 说明
q=Queue() 初始化Queue()对象,若括号中没有指定最大可接收的消息数量,或数量为负值,那么就代表可接受的消息数量没有上限(直到内存的尽头)
Queue.qsize() 返回当前队列包含的消息数量
Queue.empty() 如果队列为空,返回True,反之False
Queue.full() 如果队列满了,返回True,反之False
Queue.get([block[, timeout]]) 获取队列中的一条消息,然后将其从列队中移除,block默认值为True。1、如果block使用默认值,且没有设置timeout(单位秒),消息列队如果为空,此时程序将被阻塞(停在读取状态),直到从消息列队读到消息为止,如果设置了timeout,则会等待timeout秒,若还没读取到任何消息,则抛出"Queue.Empty"异常。2、如果block值为False,消息列队如果为空,则会立刻抛出"Queue.Empty"异常
Queue.get_nowait() 相当Queue.get(False)
Queue.put(item,[block[, timeout]]) 将item消息写入队列,block默认值为True。1、如果block使用默认值,且没有设置timeout(单位秒),消息列队如果已经没有空间可写入,此时程序将被阻塞(停在写入状态),直到从消息列队腾出空间为止,如果设置了timeout,则会等待timeout秒,若还没空间,则抛出"Queue.Full"异常。 2、如果block值为False,消息列队如果没有空间可写入,则会立刻抛出"Queue.Full"异常
Queue.put_nowait(item) 相当Queue.put(item, False)

2. Queue的使用

可以使用multiprocessing模块的Queue实现多进程之间的数据传递,Queue本身是一个消息列队程序,首先用一个小实例来演示一下Queue的工作原理:

#coding=utf-8from multiprocessing import Queueq=Queue(3) #初始化一个Queue对象,最多可接收三条put消息q.put("消息1") q.put("消息2")print(q.full())  #Falseq.put("消息3")print(q.full()) #True#因为消息列队已满下面的try都会抛出异常,第一个try会等待2秒后再抛出异常,第二个Try会立刻抛出异常try:    q.put("消息4",True,2)except:    print("消息列队已满,现有消息数量:%s"%q.qsize())try:    q.put_nowait("消息4")except:    print("消息列队已满,现有消息数量:%s"%q.qsize())#推荐的方式,先判断消息列队是否已满,再写入if not q.full():    q.put_nowait("消息4")#读取消息时,先判断消息列队是否为空,再读取if not q.empty():    for i in range(q.qsize()): print(q.get_nowait())

运行结果:

FalseTrue消息列队已满,现有消息数量:3消息列队已满,现有消息数量:3消息1消息2消息3

3. Queue实例

我们以Queue为例,在父进程中创建两个子进程,一个往Queue里写数据,一个从Queue里读数据:

from multiprocessing import Process, Queueimport os, time, random# 写数据进程执行的代码:def write(q):    for value in ['A', 'B', 'C']: print('Put %s to queue...' % value) q.put(value) time.sleep(random.random())# 读数据进程执行的代码:def read(q):    while True: if not q.empty():     value = q.get(True)     print('Get %s from queue.' % value)     time.sleep(random.random()) else:     breakif __name__=='__main__':    # 父进程创建Queue,并传给各个子进程:    q = Queue()    pw = Process(target=write, args=(q,))    pr = Process(target=read, args=(q,))    # 启动子进程pw,写入:    pw.start() # 等待pw结束:    pw.join()    # 启动子进程pr,读取:    pr.start()    pr.join()    # pr进程里是死循环,无法等待其结束,只能强行终止:    print('')    print('所有数据都写入并且读完')

运行结果:
在这里插入图片描述

四、进程间同步-Lock

锁是为了确保数据一致性。比如读写锁,每个进程给一个变量增加 1,但是如果在一个进程读取但还没有写入的时候,另外的进程也同时读取了,并写入该值,则最后写入的值是错误的,这时候就需要加锁来保持数据一致性。

通过使用Lock来控制一段代码在同一时间只能被一个进程执行。Lock对象的两个方法,acquire()用来获取锁,release()用来释放锁。当一个进程调用acquire()时,如果锁的状态为unlocked,那么会立即修改为locked并返回,这时该进程即获得了锁。如果锁的状态为locked,那么调用acquire()的进程则阻塞。

1. Lock的语法说明

  • lock = multiprocessing.Lock(): 创建一个锁

  • lock.acquire() :获取锁

  • lock.release() :释放锁

  • with lock:自动获取、释放锁 类似于 with open() as f:

2. 程序不加锁时

import multiprocessingimport timedef add(num, value):    print('add{0}:num={1}'.format(value, num))    for i in range(0, 2): num += value print('add{0}:num={1}'.format(value, num)) time.sleep(1)if __name__ == '__main__':    lock = multiprocessing.Lock()    num = 0    p1 = multiprocessing.Process(target=add, args=(num, 1))    p2 = multiprocessing.Process(target=add, args=(num, 2))    p1.start()    p2.start()

运行结果:运得没有顺序,两个进程交替运行

add1:num=0add1:num=1add2:num=0add2:num=2add1:num=2add2:num=4

3. 程序加锁时

import multiprocessingimport timedef add(num, value, lock):    try: lock.acquire() print('add{0}:num={1}'.format(value, num)) for i in range(0, 2):     num += value     print('add{0}:num={1}'.format(value, num))     time.sleep(1)    except Exception as err: raise err    finally: lock.release()if __name__ == '__main__':    lock = multiprocessing.Lock()    num = 0    p1 = multiprocessing.Process(target=add, args=(num, 1, lock))    p2 = multiprocessing.Process(target=add, args=(num, 2, lock))    p1.start()    p2.start()

运行结果:只有当其中一个进程执行完成后,其它的进程才会去执行,且谁先抢到锁谁先执行

add1:num=0add1:num=1add1:num=2add2:num=0add2:num=2add2:num=4

五、进程池Pool

当需要创建的子进程数量不多时,可以直接利用multiprocessing中的Process动态成生多个进程,但如果是上百甚至上千个目标,手动的去创建进程的工作量巨大,此时就可以用到multiprocessing模块提供的Pool方法。

1. Pool类语法说明

语法格式multiprocessing.pool.Pool([processes[, initializer[, initargs[, maxtasksperchild[, context]]]]])

参数说明

  • processes:工作进程数目,如果 processes 为 None,则使用 os.cpu_count() 返回的值。

  • initializer:如果 initializer 不为 None,则每个工作进程将会在启动时调用 initializer(*initargs)。

  • maxtasksperchild:一个工作进程在它退出或被一个新的工作进程代替之前能完成的任务数量,为了释放未使用的资源。

  • context:用于指定启动的工作进程的上下文。

两种方式向进程池提交任务

  • apply(func[, args[, kwds]]):阻塞方式。

  • apply_async(func[, args[, kwds]]):非阻塞方式。使用非阻塞方式调用func(并行执行,堵塞方式必须等待上一个进程退出才能执行下一个进程),args为传递给func的参数列表,kwds为传递给func的关键字参数列表

multiprocessing.Pool常用函数:

方法名 说明
close() 关闭Pool,使其不再接受新的任务
terminate() 不管任务是否完成,立即终止
join() 主进程阻塞,等待子进程的退出, 必须在close或terminate之后使用

2. Pool实例

初始化Pool时,可以指定一个最大进程数,当有新的请求提交到Pool中时,如果池还没有满,那么就会创建一个新的进程用来执行该请求;但如果池中的进程数已经达到指定的最大值,那么该请求就会等待,直到池中有进程结束,才会用之前的进程来执行新的任务,请看下面的实例:

# -*- coding:utf-8 -*-from multiprocessing import Poolimport os, time, randomdef worker(msg):    t_start = time.time()    print("%s开始执行,进程号为%d" % (msg,os.getpid()))    # random.random()随机生成0~1之间的浮点数    time.sleep(random.random()*2)     t_stop = time.time()    print(msg,"执行完毕,耗时%0.2f" % (t_stop-t_start))po = Pool(3)  # 定义一个进程池,最大进程数3for i in range(0,10):    # Pool().apply_async(要调用的目标,(传递给目标的参数元祖,))    # 每次循环将会用空闲出来的子进程去调用目标    po.apply_async(worker,(i,))print("----start----")po.close()  # 关闭进程池,关闭后po不再接收新的请求po.join()  # 等待po中所有子进程执行完成,必须放在close语句之后print("-----end-----")

运行结果:

----start----0开始执行,进程号为214661开始执行,进程号为214682开始执行,进程号为214670 执行完毕,耗时1.013开始执行,进程号为214662 执行完毕,耗时1.244开始执行,进程号为214673 执行完毕,耗时0.565开始执行,进程号为214661 执行完毕,耗时1.686开始执行,进程号为214684 执行完毕,耗时0.677开始执行,进程号为214675 执行完毕,耗时0.838开始执行,进程号为214666 执行完毕,耗时0.759开始执行,进程号为214687 执行完毕,耗时1.038 执行完毕,耗时1.059 执行完毕,耗时1.69-----end-----

3. 进程池中的Queue

如果要使用Pool创建进程,就需要使用multiprocessing.Manager()中的Queue()

而不是multiprocessing.Queue(),否则会得到一条如下的错误信息:RuntimeError: Queue objects should only be shared between processes through inheritance.

下面的实例演示了进程池中的进程如何通信:

# -*- coding:utf-8 -*-# 修改import中的Queue为Managerfrom multiprocessing import Manager,Poolimport os,time,randomdef reader(q):    print("reader启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))    for i in range(q.qsize()): print("reader从Queue获取到消息:%s" % q.get(True))def writer(q):    print("writer启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))    for i in "itcast": q.put(i)if __name__=="__main__":    print("(%s) start" % os.getpid())    q = Manager().Queue()  # 使用Manager中的Queue    po = Pool()    po.apply_async(writer, (q,))    time.sleep(1)  # 先让上面的任务向Queue存入数据,然后再让下面的任务开始从中取数据    po.apply_async(reader, (q,))    po.close()    po.join()    print("(%s) End" % os.getpid())

运行结果:

(11095) startwriter启动(11097),父进程为(11095)reader启动(11098),父进程为(11095)reader从Queue获取到消息:ireader从Queue获取到消息:treader从Queue获取到消息:creader从Queue获取到消息:areader从Queue获取到消息:sreader从Queue获取到消息:t(11095) End

六、进程、线程对比

1. 功能

进程:能够完成多任务,比如 在一台电脑上能够同时运行多个QQ
线程:能够完成多任务,比如 一个QQ中的多个聊天窗口

100天精通Python(进阶篇)——第38天:多进程【文末送书三本】
定义的不同

  • 进程是系统进行资源分配和调度的一个独立单位.

  • 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.

2. 区别

  • 一个程序至少有一个进程,一个进程至少有一个线程.
    -线程的划分尺度小于进程(资源比进程少),使得多线程程序的并发性高。
    -进程在执行过程中拥有独立的内存单元,而多个线程共享内存,从而极大地提高了程序的运行效率
    100天精通Python(进阶篇)——第38天:多进程【文末送书三本】
  • 线线程不能够独立执行,必须依存在进程中
  • 可以将进程理解为工厂中的一条流水线,而其中的线程就是这个流水线上的工人
    100天精通Python(进阶篇)——第38天:多进程【文末送书三本】

3. 优缺点

  • 线程:线程执行开销小,但不利于资源的管理和保护
  • 进程:进程执行开销大,但利于资源的管理和保护

如何让学习变得更加高效呢?

1. 编程小白选手

很多刚入门编程的小白学习了基础语法,却不知道语法的用途,不知道如何加深映像,不知道如何提升自己,这个时候每天刷自主刷一道题就非常重要(百炼成神),可以去牛客网上的编程初学者入门训练。该专题为编程入门级别,适合刚学完语法的小白练习,题目涉及编程基础语法,基本结构等,每道题带有练习模式和考试模式,可还原考试模式进行模拟,也可通过练习模式进行练习。

链接地址:牛客网 | 编程初学者入门训练
100天精通Python(进阶篇)——第38天:多进程【文末送书三本】
2. 编程进阶选手

当基础练习完已经逐步掌握了各知识要点后,这个时候去专项练习中学习数据结构、算法基础、计算机基础等。先从简单的入手,感觉上来了再做中等难度,以及较难的题目。这三样是面试中必考的知识点,我们只有坚持每日自己去多加练习,拒绝平躺持续刷题,不断提升自己才能冲击令人满意的公司。

链接地址:牛客网 | 专项练习
100天精通Python(进阶篇)——第38天:多进程【文末送书三本】
速度上号,大家一起冲击大厂,有疑问评论区留言解答!!!

🎉参与抽粉丝送书啦

以后每周新文评论区抽两个粉丝送书,大家持续关注此专栏:《每周免费送书活动》专栏

书籍展示:《 爬虫逆向进阶实战》

在这里插入图片描述

【抽奖方式】关注博主、点赞收藏文章后,评论区留言:人生苦短,我用Python!!!博主会用爬虫代码随机抽取三人送书! 【开奖时间】:截止到周日晚8点,博主会用爬虫代码随机抽取三人送书!


【书籍内容简介】

  • 本书以爬虫逆向方向的相关技术和岗位要求进行撰写,总结了爬虫的架构体系、主流框架和未来发展。书中包括各种自动化工具、抓包工具、逆向工具的使用。核心内容以Web Js逆向、安卓逆向、小程序逆向为主,结合三十多个实战案例进行分析,内容从易到难,循序渐进。另外还对主流的反爬虫技术进行了讲解,包括传输协议、验证码体系、字符集映射、行为和指纹等。扫描封底二维码,可获得反爬虫补充知识;扫描节中二维码,可获得配套视频讲解知识。
  • 本书适合对爬虫逆向感兴趣,想进一步提升自我的程序员参考阅读。

妊娠纹产品大全