Python之路(第三十七篇)并发编程:进程、multiprocess模块、创建进程方式、join()、守护进程
一、在python程序中的进程操作
之前已经了解了很多进程相关的理论知识,了解进程是什么应该不再困难了,运行中的程序就是一个进程。所有的进程都是通过它的父进程来创建的。因此,运行起来的python程序也是一个进程,那么也可以在程序中再创建进程。多个进程可以实现并发效果,也就是说,当程序中存在多个进程的时候,在某些时候,就会让程序的执行速度变快。在python中实现多进程需要借助python中强大的模块。
二、multiprocess模块
python中的多线程无法利用多核优势,如果想要充分地使用多核CPU的资源(os.cpu_count()查看),在python中大部分情况需要使用多进程。Python提供了multiprocessing。 multiprocessing模块用来开启子进程,并在子进程中执行我们定制的任务(比如函数),该模块与多线程模块threading的编程接口类似。
multiprocessing模块的功能众多:支持子进程、通信和共享数据、执行不同形式的同步,提供了Process、Queue、Pipe、Lock等组件。
需要再次强调的一点是:与线程不同,进程没有任何共享状态,进程修改的数据,改动仅限于该进程内。
Process类的介绍
创建进程的类:
Process([group [, target [, name [, args [, kwargs]]]]]),由该类实例化得到的对象,表示一个子进程中的任务(尚未启动)
强调:
1. 需要使用关键字的方式来指定参数
2. args指定的为传给target函数的位置参数,是一个元组形式,必须有逗号
参数介绍:
group参数未使用,值始终为None
target表示调用对象,即子进程要执行的任务
args表示调用对象的位置参数元组,args=(1,2,'egon',)
kwargs表示调用对象的字典,kwargs={'name':'egon','age':18}
name为子进程的名称
方法介绍:
p.start():启动进程,并调用该子进程中的p.run()
p.run():进程启动时运行的方法,正是它去调用target指定的函数,我们自定义类的类中一定要实现该方法
p.terminate():强制终止进程p,不会进行任何清理操作,如果p创建了子进程,该子进程就成了僵尸进程,使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放,进而导致死锁
p.is_alive():如果p仍然运行,返回True
p.join([timeout]):主线程等待p终止(强调:是主线程处于等的状态,而p是处于运行的状态)。timeout是可选的超时时间,需要强调的是,p.join只能join住start开启的进程,而不能join住run开启的进程
属性介绍:
p.daemon:默认值为False,如果设为True,代表p为后台运行的守护进程,当p的父进程终止时,p也随之终止,并且设定为True后,p不能创建自己的新进程,必须在p.start()之前设置
p.name:进程的名称
p.pid:进程的pid
p.exitcode:进程在运行时为None、如果为–N,表示被信号N结束(了解即可)
p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性,这类连接只有在具有相同的身份验证键时才能成功(了解即可)
Process类的使用
注意:在windows中Process()必须放到# if name == 'main':下
创建并开启子进程的两种方式
方式一
#方式一:直接用函数
import multiprocessing
# from multiprocessing import Process 这种导入模块的方式可以在下面代码中直接写Process(target= ,args=)
import time
def hi(name):
print("hello %s"%name)
time.sleep(1)
if __name__ == "__main__":
p = multiprocessing.Process(target=hi,args=("nick",))
p.start()
p.join()
print("ending...")
方式二
#开启进程的方式二,在类中启动进程
import time
import multiprocessing
class Foo(multiprocessing.Process): #这里继承 multiprocessing.Process类
def __init__(self,name):
super().__init__()
self.name = name
def run(self):
print("hello %s" % self.name)
time.sleep(3)
if __name__ == "__main__":
p = Foo("nick")
p.start() #这里执行start()会直接调用类的run()方法
# p.join()
print("ending...")
进程直接的内存空间是隔离的
import multiprocessing
n = 100
def work():
global n
n = 0
print("子进程内的n", n)
if __name__ == '__main__':
p = multiprocessing.Process(target=work)
p.start()
print("主进程内的n", n)
输出结果
主进程内的n 100
子进程内的n 0
分析:由于子进程和主进程是隔离的,所以即使在子进程里有global关键字,主进程同一变量的值也没变。
Process对象的join方法
在主进程运行过程中如果想并发地执行其他的任务,我们可以开启子进程,此时主进程的任务与子进程的任务分两种情况
情况一:在主进程的任务与子进程的任务彼此独立的情况下,主进程的任务先执行完毕后,主进程还需要等待子进程执行完毕,然后统一回收资源。
情况二:如果主进程的任务在执行到某一个阶段时,需要等待子进程执行完毕后才能继续执行,就需要有一种机制能够让主进程检测子进程是否运行完毕,在子进程执行完毕后才继续执行,否则一直在原地阻塞,这就是join方法的作用。
例子
from multiprocessing import Process
import time
def func(args):
print('-----',args)
time.sleep(2)
print("end---")
if __name__ == '__main__':
p = Process(target=func,args=(1,))
p.start()
print('哈哈哈哈')
p.join()#join()的作用是阻塞主进程,使得主进程等待子进程执行完才把自己结束
print("主进程运行完了")
例子2
from multiprocessing import Process
import time
import random
def piao(name):
print('%s is talking' %name)
time.sleep(random.randint(1,3))
print('%s is talking end' %name)
p1=Process(target=piao,args=('nick',))
p2=Process(target=piao,args=('jack',))
p3=Process(target=piao,args=('pony',))
p4=Process(target=piao,args=('charles',))
p1.start()
p2.start()
p3.start()
p4.start()
#疑问:既然join是等待进程结束,那么像下面这样写,进程不就又变成串行的了吗?
#当然不是了,必须明确:p.join()是让谁等?
#很明显p.join()是让主线程等待p的结束,卡住的是主线程而绝非进程p,
#详细解析如下:
#进程只要start就会在开始运行了,所以p1-p4.start()时,系统中已经有四个并发的进程了
#而p1.join()是在等p1结束,没错p1只要不结束主线程就会一直卡在原地,这也是问题的关键
#join是让主线程等,而p1-p4仍然是并发执行的,p1.join的时候,其余p2,p3,p4仍然在运行,等#p1.join结束,可能p2,p3,p4早已经结束了,这样p2.join,p3.join.p4.join直接通过检测,无需等待
# 所以4个join花费的总时间仍然是耗费时间最长的那个进程运行的时间
p1.join()
p2.join()
p3.join()
p4.join()
print('主线程')
#上述启动进程与join进程可以简写为
# p_l=[p1,p2,p3,p4]
#
# for p in p_l:
# p.start()
#
# for p in p_l:
# p.join()
Process对象的其他方法或属性
进程对象的其他方法:terminate与is_alive、name与pid
例子
import multiprocessing
import time
def task(name, t):
print("进程正在运行。。。%s--%s" % (name, time.asctime()))
time.sleep(t)
print("进程结束了%s--%s" % (name, time.asctime()))
if __name__ == "__main__":
p1 = multiprocessing.Process(target=task, args=("nick", 5), name="进程1") # 注意这里的参数name不是函数的参数
p2 = multiprocessing.Process(target=task, args=("nicholas", 2), name="进程2")
p_list = []
p_list.append(p1)
p_list.append(p2)
print("进程是否存活", p1.is_alive())
for p in p_list:
p.start()
print(p.name) # 进程.name输出进程的名称
print(p.name, p.pid) # 进程对象.pid也可以输出子进程的ID号,
print("进程是否存活", p1.is_alive()) # 判断子进程是否存活
# p2.terminate()#不管进程是否执行完,立刻结束进程
for p in p_list:
p.join()
print("ending...")
通过os模块查看pid和ppid
import multiprocessing
import os class Foo(multiprocessing.Process): def __init__(self,name):
super().__init__()
self.name = name def run(self):
print("hi %s,子进程号是%s"%(self.name,os.getpid()))#输出当前的进程的pid if __name__ == "__main__":
p = Foo("nick")
p.start()
print("主进程是%s"%os.getppid()) #这里的主进程好就是执行这个py文件的程序,这里是pycharm,
# 如果用命令终端执行py文件则主进程是命令终端的号
#os.getppid()是输出当前进程的父进程pid号
#os.getpid()是输出当前的进程的pid
僵尸进程与孤儿进程(了解)
一:僵尸进程(有害)
僵尸进程:一个进程使用fork创建子进程,如果子进程退出,而父进程并没有调用wait或waitpid获取子进程的状态信息,那么子进程的进程描述符仍然 保存在系统中。这种进程称之为僵死进程。详解如下
我们知道在unix/linux中,正常情况下子进程是通过父进程创建的,子进程在创建新的进程。子进程的结束和父进程的运行是一个异步过程,即父进程永远无 法预测子进程到底什么时候结束,如果子进程一结束就立刻回收其全部资源,那么在父进程内将无法获取子进程的状态信息。
因此,UNⅨ提供了一种机制可以保证父进程可以在任意时刻获取子进程结束时的状态信息:
1、在每个进程退出的时候,内核释放该进程所有的资源,包括打开的文件,占用的内存等。但是仍然为其保留一定的信息(包括进程号the process ID, 退出状态the termination status of the process,运行时间the amount of CPU time taken by the process等)
2、直到父进程通过wait / waitpid来取时才释放. 但这样就导致了问题,如果进程不调用wait / waitpid的话,那么保留的那段信息就不会释放,其 进程号就会一直被占用,但是系统所能使用的进程号是有限的,如果大量的产生僵死进程,将因为没有可用的进程号而导致系统不能产生新的进程. 此即为僵尸 进程的危害,应当避免。
任何一个子进程(init除外)在exit()之后,并非马上就消失掉,而是留下一个称为僵尸进程(Zombie)的数据结构,等待父进程处理。这是每个子进程在 结束时都要经过的阶段。如果子进程在exit()之后,父进程没有来得及处理,这时用ps命令就能看到子进程的状态是“Z”。如果父进程能及时 处理,可能用ps命 令就来不及看到子进程的僵尸状态,但这并不等于子进程不经过僵尸状态。 如果父进程在子进程结束之前退出,则子进程将由init接管。init将会以父进程的 身份对僵尸状态的子进程进行处理。
二:孤儿进程(无害)
孤儿进程:一个父进程退出,而它的一个或多个子进程还在运行,那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养,并由init进 程对它们完成状态收集工作。
孤儿进程是没有父进程的进程,孤儿进程这个重任就落到了init进程身上,init进程就好像是一个民政局,专门负责处理孤儿进程的善后工作。每当出现一个 孤儿进程的时候,内核就把孤 儿进程的父进程设置为init,而init进程会循环地wait()它的已经退出的子进程。这样,当一个孤儿进程凄凉地结束了其生命周期的 时候,init进程就会出面处理它的一切善后工作。因此孤儿进程并不会有什么危害。
三:僵尸进程危害场景:
例如有个进程,它定期的产 生一个子进程,这个子进程需要做的事情很少,做完它该做的事情之后就退出了,因此这个子进程的生命周期很短,但是,父进程 只管生成新的子进程,至于子进程 退出之后的事情,则一概不闻不问,这样,系统运行上一段时间之后,系统中就会存在很多的僵死进程,倘若用ps命令查看的话, 就会看到很多状态为Z的进程。 严格地来说,僵死进程并不是问题的根源,罪魁祸首是产生出大量僵死进程的那个父进程。因此,当我们寻求如何消灭系统中大量的 僵死进程时,答案就是把产生大 量僵死进程的那个元凶枪毙掉(也就是通过kill发送SIGTERM或者SIGKILL信号啦)。枪毙了元凶进程之后,它产生的僵死进程 就变成了孤儿进 程,这些孤儿进程会被init进程接管,init进程会wait()这些孤儿进程,释放它们占用的系统进程表中的资源,这样,这些已经僵死的孤儿进程 就能瞑目而去了。
守护进程
会随着主进程的结束而结束。
主进程创建守护进程
其一:守护进程会在主进程代码执行结束后就终止
其二:守护进程内无法再开启子进程,否则抛出异常:AssertionError: daemonic processes are not allowed to have children
注意:进程之间是互相独立的,主进程代码运行结束,守护进程随即终止,不管守护进程执行没执行完。
例子1
from multiprocessing import Process
import time
def foo():
print(123)
time.sleep(1)
print("end123")
def bar():
print(456)
time.sleep(3)
print("end456")
if __name__ == '__main__':
p1=Process(target=foo)
p2=Process(target=bar)
p1.daemon=True ##一定要在p1.start()前设置,设置p1为守护进程,
# 禁止p1创建子进程,并且父进程代码执行结束,p1即终止运行
p1.start()
p2.start()
print("main-------") #只要终端打印出这一行内容,那么守护进程p1也就跟着结束掉了
例子2
# 主进程代码运行完毕,守护进程就会结束
from multiprocessing import Process
import time
def foo():
print(123)
time.sleep(1)
print("end123")
def bar():
print(456)
time.sleep(3)
print("end456")
if __name__ == '__main__':
p1 = Process(target=foo)
p2 = Process(target=bar)
p1.daemon = True
p1.start()
p2.start()
print("main-------") # 打印该行则主进程代码结束,则守护进程p1应该被终止,
# 可能会有p1任务执行的打印信息123,因为主进程打印main----时,p1也执行了,但是随即被终止
#这时p1可能会被执行,也可能不会被执行
参考资料
[1]http://www.cnblogs.com/Anker/p/3271773.html
Python之路(第三十七篇)并发编程:进程、multiprocess模块、创建进程方式、join()、守护进程的更多相关文章
- Python之路(第三十三篇) 网络编程:socketserver深度解析
一.socketserver 模块介绍 socketserver是标准库中的一个高级模块,用于网络客户端与服务器的实现.(version = "0.4") 在python2中写作S ...
- Python之路(第三十一篇) 网络编程:简单的tcp套接字通信、粘包现象
一.简单的tcp套接字通信 套接字通信的一般流程 服务端 server = socket() #创建服务器套接字 server.bind() #把地址绑定到套接字,网络地址加端口 server.lis ...
- Python之路(第三十篇) 网络编程:socket、tcp/ip协议
一.客户端/服务器架构 1.硬件C/S架构(打印机) 打印机作为一个服务端,电脑连接打印机进行打印 2.软件C/S架构 互联网中处处是C/S架构 如谷歌网站是服务端,你的浏览器是客户端(B/S架构也是 ...
- Python之路【第十七篇】:Django【进阶篇 】
Python之路[第十七篇]:Django[进阶篇 ] Model 到目前为止,当我们的程序涉及到数据库相关操作时,我们一般都会这么搞: 创建数据库,设计表结构和字段 使用 MySQLdb 来连接 ...
- Python之路【第十七篇】:Django之【进阶篇】
Python之路[第十七篇]:Django[进阶篇 ] Model 到目前为止,当我们的程序涉及到数据库相关操作时,我们一般都会这么搞: 创建数据库,设计表结构和字段 使用 MySQLdb 来连接 ...
- Python之路【第十七篇】:Django【进阶篇】
Python之路[第十七篇]:Django[进阶篇 ] Model 到目前为止,当我们的程序涉及到数据库相关操作时,我们一般都会这么搞: 创建数据库,设计表结构和字段 使用 MySQLdb 来连接 ...
- Python之路【第十七篇】:Python并发编程|协程
一.协程 协程,又叫微线程,纤程.英文名Coroutine.协程本质上就是一个线程 优点1:协程极高的执行效率.因为子程序切换不是线程切换,而是由程序自身控制,因此,没有线程切换的开销,和多线程比,线 ...
- Python之路(第四十七篇) 协程:greenlet模块\gevent模块\asyncio模块
一.协程介绍 协程:是单线程下的并发,又称微线程,纤程.英文名Coroutine.一句话说明什么是线程:协程是一种用户态的轻量级线程,即协程是由用户程序自己控制调度的. 协程相比于线程,最大的区别在于 ...
- Python之路【第十七篇】Django进阶篇
规范 确立规范的好处: 代码可读性高 方便代码的定位极其查找 为以后代码扩容带来便利 场景: 在多个APP的场景下,单个app的URL函数功能较多的时候,我们可以通过以下方法来解决. 把Views写成 ...
随机推荐
- 与大家分享学习微信小程序开发的一些心得
因为我也才开始学习微信小程序不久,下文也是现在的一时之言,大家有不同的想法也可以在评论里共同交流讨论,希望文章能给大家提供一点点帮助. 最近接触到了一些前端框架,像Vue.js,React,发现小程序 ...
- ffplay流程分析
void main() { is = stream_open(input_filename, file_iformat); } static VideoState *stream_open(const ...
- JAVA_Class.forName()用法详解
Class.forName(xxx.xx.xx)返回的是一个类. Class.forName(xxx.xx.xx)的作用是要求JVM查找并加载指定的类,JVM会执行该类的静态代码段. Class.fo ...
- 一个request引发的bug
有很多错误由于需要是多线程是才会发生,导致经常在开发时很难发现, import java.lang.reflect.ParameterizedType; import java.util.List; ...
- Mac 下安装nvm 后vscode 输入node -v 不起作用
今天下午,我因为要安装不同的node版本,所有安装了nvm下载了两个不同版本的node,并且配置了环境变量. 在命令行窗口中使用起来没有任何问题,但是在vs code中敲的时候node -v 显示no ...
- HTML基本入门完成
四. (一)丶下拉框select元素:一般可以创建单选或多选菜单.<select>与<option>一般同时使用,select代表下拉框,option代表他的每一项. 1.基本 ...
- Oracle主从同步、双向同步的配置
(本教程展示了Windows环境的oracle数据库主从同步,Linux环境一样也可以) (把主数据库obpm 和从数据库orcl 用实际的数据库名给替换掉) (配置主从同步后,再配置双向同步,可能会 ...
- pandas,pd.ExcelWriter保存结果到已存在的excel文件中
背景:pandas支持将DataFrame数据直接保存到excel中 保存的case如下: import pandas as pd with pd.ExcelWriter('a.xls') as ...
- python异常捕捉以及处理
看标题觉得高大上,好像能处理所有的异常.但是,事实是只能按照字面的意思来理解这一段话. 众所周知写代码哪有不出bug的? 那么出现了bug 我们不想让程序因为bug的存在而退出.那么要怎么做呢? 今天 ...
- C#给checkboxList设置js选中事件
C#: for (int i = 0; i < this.CheckBoxList1.Items.Count; i++) { this.CheckBoxL ...