python网络-多进程(21)
一、什么是进程
进程(Process)是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础。在早期面向进程设计的计算机结构中,进程是程序的基本执行实体;在当代面向线程设计的计算机结构中,进程是线程的容器。程序是指令、数据及其组织形式的描述,进程是程序的实体。---来自百度百科
二、程序和进程的关系
三、fork()
#-*- coding:utf-8 -*- import os pid = os.fork()if pid == 0:print("子进程") else:print("主进程")
运行结果为:
主进程 子进程
getpid()、getppid()
import os pid = os.fork()if pid == 0:print("我是子进程(%d),我的父进程(%d)"%(os.getpid(),os.getppid())) else:print("我是父进程(%d),我的子进程(%d)"%(os.getpid,pid)) print("父子进程都可以执行的代码")
运行结果为:
我是父进程(4488),我的子进程(4491) 父子进程都可以执行的代码 我是子进程(4491),我的父进程(4488) 父子进城都可以执行的代码
说明:
- 程序执⾏到os.fork()时,操作系统会创建⼀个新的进程(⼦进程),然后复制⽗进程的所有信息到⼦进程中
- 然后⽗进程和⼦进程都会从fork()函数中得到⼀个返回值,在⼦进程中这个值⼀定是0,⽽⽗进程中是⼦进程的id号
- 普通的函数调⽤,调⽤⼀次,返回⼀次,但是fork()调⽤⼀次,返回两次,因为操作系统⾃动把当前进程(称为⽗进程)复制了⼀份(称为⼦进程),然后,分别在⽗进程和⼦进程内返回
- ⼀个⽗进程可以fork出很多⼦进程,所以,⽗进程要记下每个⼦进程的ID,⽽⼦进程只需要调⽤getppid()就可以拿到⽗进程的ID
多个fork()
#-*- coding:utf-8 -*- import os pid1 = os.fork() if pid1 == 0:#子进程1print("1:我是第一个子进程%d,我的父进程是%d"%(os.getpid(),os.getppid())) else:#父进程print("2:我是父进程%d"%os.getpid()) pid2 = os.fork() if pid2==0:print("3:我是谁%d,我的父进程是%d"%(os.getpid(),os.getppid())) else:print("4:我是谁%d,我的父进程是%d"%(os.getpid(),os.getppid()))
运行结果为:
2:我是父进程3189 1:我是第一个子进程3190,我的父进程是3189 4:我是谁3190,我的父进程是3189 3:我是谁3191,我的父进程是3189 3:我是谁3192,我的父进程是3190 4:我是谁3189,我的父进程是991
说明:
- pid2开辟的进程将会被子进程1和父进程同时调用
- 当父线程调用pid2
- if pid2 == 0:会在创建一个子进程2,父进程是主进程
- else:及父线程本身,不会再创建进程
- 当子进程1调用pid2
- if pid2 ==0:会创建一个子子进程,父进程是子进程1
- else:即子线程1本身,不会再创建进程
其实上面的代码就相当于:
#-*- coding:utf-8 -*- import os pid1 = os.fork() if pid1 == 0:#子进程1print("1:我是第一个子进程%d,我的父进程是%d"%(os.getpid(),os.getppid())) else:#父进程print("2:我是父进程%d"%os.getpid())pid2 = os.fork() if pid1 == 0:#子进程1if pid2==0:#子子进程print("3:我是谁%d,我的父进程是%d"%(os.getpid(),os.getppid()))else:#子进程1print("4:我是谁%d,我的父进程是%d"%(os.getpid(),os.getppid())) else:#父进程if pid2==0:#子进程2print("3:我是谁%d,我的父进程是%d"%(os.getpid(),os.getppid()))else:#父进程print("4:我是谁%d,我的父进程是%d"%(os.getpid(),os.getppid()))
四、多进程使用全局变量
import os import timeg_num = 100ret = os.fork() if ret == 0:print("----process-1----")g_num += 1print("---process-1 g_num=%d---"%g_num) else:time.sleep(3)print("----process-2----")print("---process-2 g_num=%d---"%g_num)
运行结果为:
----process-1---- ---process-1 g_num=101--- ----process-2---- ---process-2 g_num=100---
说明:多线程间全局变量是不共享的,每个线程里面全局变量都是独自一份的
五、multiprocessing
由于Python是跨平台的,自然也应该提供一个跨平台的多进程支持。multiprocessing模块就是跨平台版本的多进程模块。
multiprocessing模块提供了一个Process类来代表一个进程对象
#coding=utf-8 from multiprocessing import Process import os#子进程要执行的代码 def sub_process(name):print("这是在子进程中,name=%s,pid=%d"%(name,os.getpid()))if __name__ == "__main__":print("父进程:%d"%os.getpid())p=Process(target=sub_process,args=("test",))print("----子进程将要开启----")p.start()#开启子进程 p.join()#用于等待子进程执行完毕再继续往下执行print("----子进程已经结束----")
运行结果为:
父进程:8344 ----子进程将要开启---- 这是在子进程中,name=test,pid=9064 ----子进程已经结束----
说明
- 创建子进程时,只需要传入一个执行函数和函数的参数,创建一个Process实例,用start()方法启动,这样创建进程比fork()还要简单。
- join()方法可以等待子进程结束后再继续往下运行,通常用于进程间的同步。
Process语法结构如下:
Process([group [, target [, name [, args [, kwargs]]]]])
1 group:参数未使用,值始终为None 2 target:表示调用对象,即子进程要执行的任务 3 args:表示调用对象的位置参数元组,args=(1,2,'a',) 4 kwargs:表示调用对象的字典,kwargs={'name':'a','age':18} 5 name:为子进程的名称
Process类常用方法:
1 start():启动进程,并调用该子进程中的p.run() 2 run():进程启动时运行的方法,正是它去调用target指定的函数,我们自定义类的类中一定要实现该方法 3 terminate():强制终止进程p,不会进行任何清理操作,如果p创建了子进程,该子进程就成了僵尸进程,使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放,进而导致死锁 4 is_alive():如果p仍然运行,返回True 5 join([timeout]):主线程等待p终止(强调:是主线程处于等的状态,而p是处于运行的状态)。timeout是可选的超时时间,需要强调的是,p.join只能join住start开启的进程,而不能join住run开启的进程
Process类常用属性:
1 daemon:默认值为False,如果设为True,代表p为后台运行的守护进程,当p的父进程终止时,p也随之终止,并且设定为True后,p不能创建自己的新进程,必须在p.start()之前设置 2 name:进程的名称 3 pid:进程的pid 4 exitcode:进程在运行时为None、如果为–N,表示被信号N结束(了解即可) 5 authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性,这类连接只有在具有相同的身份验证键时才能成功(了解即可)
#coding=utf-8 from multiprocessing import Process import time import os#两个子进程将会调用的两个方法 print("1:%d"%os.getpid()) def worker_1(interval):print("worker_1:父进程(%s),当前进程(%s)"%(os.getppid(),os.getpid()))t_start = time.time()time.sleep(interval) #程序将会被挂起interval秒t_end = time.time()print("worker_1,执行时间为'%0.2f'秒"%(t_end - t_start))print("2:%d"%os.getpid()) def worker_2(interval):print("worker_2,父进程(%s),当前进程(%s)"%(os.getppid(),os.getpid()))t_start = time.time()time.sleep(interval)t_end = time.time()print("worker_2,执行时间为'%0.2f'秒"%(t_end - t_start))#输出当前程序的ID print("3:%d"%os.getpid()) if __name__=='__main__':print("4:%d"%os.getpid())p1=Process(target=worker_1,args=(2,))p2=Process(target=worker_2,name="Se7eN_HOU",args=(1,))print("5:%d"%os.getpid())p1.start()p2.start()#同时父进程仍然往下执行,如果p2进程还在执行,将会返回Trueprint("p2.is_alive=%s"%p2.is_alive())#输出p1和p2进程的别名和pidprint("p1.name=%s"%p1.name)print("p1.pid=%s"%p1.pid)print("p2.name=%s"%p2.name)print("p2.pid=%s"%p2.pid)print("6:%d"%os.getpid())#join括号中不携带参数,表示父进程在这个位置要等待p1进程执行完成后,再继续执行下面的语句,一般用于进程间的数据同步 p1.join()print("p1.is_alive=%s"%p1.is_alive())p2.join() print("7:%d"%os.getpid())
运行结果为:
1:10452 2:10452 3:10452 4:10452 5:10452 p2.is_alive=True p1.name=Process-1 p1.pid=10688 p2.name=Se7eN_HOU p2.pid=2192 6:10452 1:2192 2:2192 3:2192 7:2192 worker_2,父进程(10452),当前进程(2192) worker_2,执行时间为'1.00'秒 1:10688 2:10688 3:10688 7:10688 worker_1:父进程(10452),当前进程(10688) worker_1,执行时间为'2.00'秒 p1.is_alive=False 7:10452
六、创建Process子类创建多进程
创建新的进程还能够使用类的方式,可以自定义一个类,继承Process类,每次实例化这个类的时候,就等同于实例化一个进程对象
from multiprocessing import Process import time import os#创建一个类,继承Process类 class My_Process(Process):def __init__(self,interval):#因为Process类本身也有__init__方法,这个子类相当于重写了这个方法,#但这样就会带来一个问题,我们并没有完全的初始化一个Process类,所以就不能使用从这个类继承的一些方法和属性,#最好的方法就是将继承类本身传递给Process.__init__方法,完成这些初始化操作Process.__init__(self)self.interval = interval#重写了Process类的run()方法def run(self):print("子进程:%d,开始执行,父进程:%d"%(os.getpid(),os.getppid()))t_start = time.time()time.sleep(self.interval)t_stop = time.time()print("子进程:%d,执行结束,耗时%0.2f秒"%(os.getpid(),t_stop-t_start))if __name__ == '__main__':t_start = time.time()print("当前进程是%d"%os.getpid())p1 = My_Process(3)p1.start()p1.join()t_stop = time.time()print("当前进程%d执行结束,耗时:%0.2f"%(os.getpid(),t_stop-t_start))
运行结果为:
当前进程是9980 子进程:7084,开始执行,父进程:9980 子进程:7084执行结束,耗时3.00秒 当前进程9980执行结束,耗时:3.23
七、进程池Pool
当需要创建的子进程数量不多时,可以直接利用multiprocessing中的Process动态成生多个进程,但如果是上百甚至上千个目标,手动的去创建进程的工作量巨大,此时就可以用到multiprocessing模块提供的Pool方法。
初始化Pool时,可以指定一个最大进程数,当有新的请求提交到Pool中时,如果池还没有满,那么就会创建一个新的进程用来执行该请求;但如果池中的进程数已经达到指定的最大值,那么该请求就会等待,直到池中有进程结束,才会创建新的进程来执行
from multiprocessing import Pool import os import time import randomdef worker(msg):t_start = time.time()print("%d进程开始执行%d"%(os.getpid(),msg))#random.random()随机生成0~1之间的浮点数time.sleep(random.random()*2) t_stop = time.time()print(msg,"执行完毕,耗时%0.2f"%(t_stop-t_start)) if __name__ == '__main__':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---- 4353进程开始执行0 4354进程开始执行1 4355进程开始执行2 2,执行完毕,耗时0.20 4355进程开始执行3 1,执行完毕,耗时1.19 4354进程开始执行4 4,执行完毕,耗时0.37 4354进程开始执行5 0,执行完毕,耗时1.57 4353进程开始执行6 5,执行完毕,耗时0.19 4354进程开始执行7 3,执行完毕,耗时1.63 4355进程开始执行8 6,执行完毕,耗时0.49 4353进程开始执行9 8,执行完毕,耗时0.75 7,执行完毕,耗时0.90 9,执行完毕,耗时0.63 -----end-----
multiprocessing.Pool常用函数解析:
- apply_async(func[, args[, kwds]]) :使用非阻塞方式调用func(并行执行,堵塞方式必须等待上一个进程退出才能执行下一个进程),args为传递给func的参数列表,kwds为传递给func的关键字参数列表;
- apply(func[, args[, kwds]]):使用阻塞方式调用func
- close():关闭Pool,使其不再接受新的任务;
- terminate():不管任务是否完成,立即终止;
- join():主进程阻塞,等待子进程的退出, 必须在close或terminate之后使用;
apply堵塞式
from multiprocessing import Pool import os import time import randomdef worker(msg):t_start = time.time()print("%d进程开始执行%d"%(os.getpid(),msg))#random.random()随机生成0~1之间的浮点数time.sleep(random.random()*2) t_stop = time.time()print(msg,"执行完毕,耗时%0.2f"%(t_stop-t_start))if __name__ == '__main__':po=Pool(3) #定义一个进程池,最大进程数3for i in range(0,10):#Pool.apply_async(要调用的目标,(传递给目标的参数元祖,))#每次循环将会用空闲出来的子进程去调用目标 po.apply(worker,(i,))print("----start----")po.close() #关闭进程池,关闭后po不再接收新的请求po.join() #等待po中所有子进程执行完成,必须放在close语句之后print("-----end-----")
运行结果为:
4400进程开始执行0 0,执行完毕,耗时1.89 4401进程开始执行1 1,执行完毕,耗时1.91 4402进程开始执行2 2,执行完毕,耗时1.64 4400进程开始执行3 3,执行完毕,耗时1.16 4401进程开始执行4 4,执行完毕,耗时1.85 4402进程开始执行5 5,执行完毕,耗时0.29 4400进程开始执行6 6,执行完毕,耗时0.19 4401进程开始执行7 7,执行完毕,耗时1.19 4402进程开始执行8 8,执行完毕,耗时0.61 4400进程开始执行9 9,执行完毕,耗时1.08 ----start---- -----end-----
说明:通过运行结果可以看出来,阻塞式会等进程池中的进程都执行完毕了才会运行主进程的start和end的打印
八、进程间的通信-Queue
1. Queue的使用
可以使用multiprocessing模块的Queue实现多进程之间的数据传递,Queue本身是一个消息列队程序,首先用一个小实例来演示一下Queue的工作原理:
#-*- coding:utf-8 -*- from multiprocessing import Queue #创建一个Queue对象,最多可接受三条put消息 q = Queue(3) q.put("消息1") q.put("消息2") print(q.full()) q.put("消息3") print(q.full())try:q.put("消息4",True,2) except :print("消息队列已满,现有消息数量:%s"%q.qsize())try:q.put_nowait("消息5") except :print("消息队列已满,现有消息数量:%s"%q.qsize())#推荐方式,先判断消息队列是否已满,在写入 if not q.full():q.put_nowait("消息6")#读取消息时,先判断消息队列是否为空,在读取 if not q.empty():for i in range(q.qsize()):print(q.get_nowait())
运行结果为:
False True 消息队列已满,现有消息数量:3 消息队列已满,现有消息数量:3 消息1 消息2 消息3
说明
初始化Queue()对象时(例如:q=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实例
我们以Queue为例,在父进程中创建两个子进程,一个往Queue里写数据,一个从Queue里读数据:
from multiprocessing import Process from multiprocessing import Queue import os import time import 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()print("所有数据都写入并且读完")
运行结果为:
Put A to Queue Put B to Queue Put C to Queue Get A from Queue Get B from Queue Get C from Queue 所有数据都写入并且读完
3. 进程池中的Queue
如果要使用Pool创建进程,就需要使用multiprocessing.Manager()中的Queue(),而不是multiprocessing.Queue(),否则会得到一条如下的错误信息:
RuntimeError: Queue objects should only be shared between processes through inheritance.
#coding=utf-8 from multiprocessing import Manager from multiprocessing import Pool import os import time import randomdef reader(q):print("reader启动(%d),父进程为(%d)"%(os.getpid(),os.getppid()))for i in range(q.qsize()):print("reader从Queue获取到的消息时:%s"%q.get(True))def writer(q):print("writer启动(%d),父进程为(%d)"%(os.getpid(),os.getppid()))for i in "Se7eN_HOU":q.put(i)if __name__ == '__main__':print("-------(%d) Start-------"%os.getpid())#使用Manager中的Queue来初始化q = Manager().Queue()po = Pool()#使用阻塞模式创建进程,这样就不需要在reader中使用死循环了,可以让writer完全执行完成后,再用reader去读取 po.apply(writer,(q,))po.apply(reader,(q,))po.close()po.join()print("-------(%d) End-------"%os.getpid())
运行结果为:
-------(880) Start------- writer启动(7744),父进程为(880) reader启动(7936),父进程为(880) reader从Queue获取到的消息时:S reader从Queue获取到的消息时:e reader从Queue获取到的消息时:7 reader从Queue获取到的消息时:e reader从Queue获取到的消息时:N reader从Queue获取到的消息时:_ reader从Queue获取到的消息时:H reader从Queue获取到的消息时:O reader从Queue获取到的消息时:U -------(880) End-------
转载于:https://www.cnblogs.com/Se7eN-HOU/p/10733583.html
python网络-多进程(21)相关推荐
- python网络与多进程编程篇
章节目录 第十六章 七层协议 第十七章 通信原理 服务器硬件配置 通信原理 第十八章 TCP/UDP传输层协议 传输数据实现流程 TCP协议数据传输 TCP协议三次握手建连接 TCP协议存在的漏洞 半 ...
- Python使用多进程提高网络爬虫的爬取速度
多线程技术并不能充分利用硬件资源和大幅度提高系统吞吐量,类似需求应使用多进程编程技术满足. 以爬取中国工程院院士简介和照片为例,参考代码如下,请自行分析目标网页结构并与参考代码进行比对.另外需要注意, ...
- Python网络爬虫之Python基本命令
往期内容 1.教你如何编写第一个简单的爬虫 2.Python编程无师自通–函数 3.在Windows平台上如何安装Python 本节主要介绍Python的一些基础语法.如果你已经学会使用Python, ...
- python商业爬虫教程_廖雪峰老师的Python商业爬虫课程 Python网络爬虫实战教程 体会不一样的Python爬虫课程...
廖雪峰老师的Python商业爬虫课程 Python网络爬虫实战教程 体会不一样的Python爬虫课程 1.JPG (53.51 KB, 下载次数: 1) 2019-8-9 08:15 上传 2.JPG ...
- python多进程优化_『Python』多进程处理
尝试学习python的多进程模组,对比多线程,大概的区别在: 1.多进程的处理速度更快 2.多进程的各个子进程之间交换数据很不方便 多进程调用方式 进程基本使用multicore() 进程池优化进程的 ...
- python爬虫文件代码大全-Python网络爬虫实战项目代码大全(长期更新,欢迎补充)...
WechatSogou[1]- 微信公众号爬虫.基于搜狗微信搜索的微信公众号爬虫接口,可以扩展成基于搜狗搜索的爬虫,返回结果是列表,每一项均是公众号具体信息字典.[1]: https://github ...
- Python 网络爬虫 001 (科普) 网络爬虫简介
Python 网络爬虫 001 (科普) 网络爬虫简介 1. 网络爬虫是干什么的 我举几个生活中的例子: 例子一: 我平时会将 学到的知识 和 积累的经验 写成博客发送到CSDN博客网站上,那么对于我 ...
- python网络编程基础(线程与进程、并行与并发、同步与异步、阻塞与非阻塞、CPU密集型与IO密集型)...
python网络编程基础(线程与进程.并行与并发.同步与异步.阻塞与非阻塞.CPU密集型与IO密集型) 目录 线程与进程并行与并发同步与异步阻塞与非阻塞CPU密集型与IO密集型 线程与进程 进程 前言 ...
- python数据采集框架_20190715《Python网络数据采集》第 1 章
<Python网络数据采集>7月8号-7月10号,这三天将该书精读一遍,脑海中有了一个爬虫大体框架后,对于后续学习将更加有全局感. 此前,曾试验看视频学习,但是一个视频基本2小时,全部拿下 ...
最新文章
- MySQL数据库聚合函数(count、max、min、sum、avg)
- 年薪百万的华为「天才少年」:谢凌曦分享「进阶」之路,选题最重要!
- [bzoj1088]扫雷
- swagger python自动化用例_如何让Swaggergenerated Python客户机正常工作?
- python生成随机码_python生成随机验证码(中文验证码)示例
- PHP开发中保证接口安全
- c盘清理代码_拒接卡顿,从c盘减负、系统修复及网络加速做起!奥利~~~
- java开发框架_Java-程序员感悟-开发人员喜欢的框架之Spring
- blob数据类型_MySQL 8.0 基本操作步骤:3.字段和数据类型的选择
- 快捷配置mysql_windows下的mysql的快捷安装方法和简单配置
- pygame精灵组有哪些方法_利用 pygame 开发一款游戏:「跳跳兔」(六)
- 在线格式化js代码的网站
- MPAndroidChart绘制图形表
- 制图折断线_机械制图的截断线与折断线的区别是什么?
- solr全文检索(多字段搜索)
- 周期串(Periodic Strings)
- IT资讯---------查看文章
- 玩转Linux与运维岗(23)
- 8月报考季,软考科目选哪个?
- Nodejs卸载、安装及环境配置