1.开启子进程的两种方式:

 # 方式1:
from multiprocessing import Process
import time def task(name):
print('%s is running'%(name))
time.sleep(2)
print('%s is done'%name) if __name__ == '__main__':
# p = Process(target=task,kwargs={'name':'子进程1'})
p = Process(target=task,args=('子进程1',))
p.start() # 仅仅只是给os发了一个信号 print('主')
'''

子进程1 is running
子进程1 is done
''' # 方式二:
from multiprocessing import Process
import time class MyProcess(Process):
def __init__(self,name):
super().__init__()
self.name = name def run(self): # 只能叫run
print('%s is running'%(self.name))
time.sleep(2)
print('%s is done'%self.name) if __name__ == '__main__':
p = MyProcess('子进程1')
p.start() print('主') '''

子进程1 is running
子进程1 is done
'''

2.查看pid:

 from multiprocessing import Process
import time
import os def task(name):
print('%s is running'%(name),os.getpid(),'parent:',os.getppid())
time.sleep(2)
print('%s is done'%name,os.getpid(),'parent:',os.getppid()) if __name__ == '__main__':
# p = Process(target=task,kwargs={'name':'子进程1'})
p = Process(target=task,args=('子进程1',))
p.start() # 仅仅只是给os发了一个信号 print('主',os.getpid(),'parent:',os.getppid()) '''
主 53400 parent: 12480 # pycharm的pid
子进程1 is running 51432 parent: 53400
子进程1 is done 51432 parent: 53400
'''
'''
cmd:
tasklist | findstr pycharm
pycharm64.exe 12480 Console 1 776,848 K
'''
'''
linux:
ps aux | grep pycharm
bj 30819 0.0 0.0 21312 976 pts/1 R+ 12:57 0:00 grep --color=auto pycharm
''' '''
僵尸进程与孤儿进程:
如果父进程一直不死,子进程变成了僵尸进程后一直占着pid ,有害!
父进程死之前,要wait()...回收僵尸进程的pid
孤儿进程,父进程先死了,linux中最大的父进程init进程会回收孤儿进程的pid
孤儿进程无害!最后init进程会回收!
如果父进程不死,僵尸进程有害,一直占着pid '''

3.Process对象的其他属性或方法:

 # 1个子进程 join 方法:
from multiprocessing import Process
import time
import os def task(name):
print('%s is running'%(name),os.getpid(),'parent:',os.getppid())
time.sleep(2)
print('%s is done'%name,os.getpid(),'parent:',os.getppid()) if __name__ == '__main__':
p = Process(target=task,args=('子进程1',))
p.start() # 仅仅只是给os发了一个信号 p.join() # 主进程等待子进程的运行完成
print('主',os.getpid(),'parent:',os.getppid())
print(p.pid) # 子进程结束了,但是变成了僵尸进程,子进程的pid 还存在
"""
子进程1 is running 43680 parent: 46512
子进程1 is done 43680 parent: 46512
主 46512 parent: 12480
43680
"""
"""
主进程结束了,基于它的子进程才会结束,即僵尸进程的pid才会被回收!
""" # 多个子进程join方法 并行
from multiprocessing import Process
import time
import os def task(name,n):
print('%s is running'%(name))
time.sleep(n) if __name__ == '__main__':
start = time.time()
p1 = Process(target=task,args=('子进程1',5))
p2 = Process(target=task,args=('子进程2',3))
p3 = Process(target=task,args=('子进程3',2))
p_l = [p1,p2,p3]
# p1.start() # 仅仅只是给os发了一个信号
# p2.start()
# p3.start()
for p in p_l:
p.start() # p1.join() # 主进程在等... 等的是最长的那个时间 5 3 2
# p2.join() # 这里任然是并发
# p3.join()
for p in p_l:
p.join() print('主',(time.time()-start))
'''
主 34504 parent: 12480
子进程1 is running 51732 parent: 34504
子进程3 is running 48864 parent: 34504
子进程2 is running 16240 parent: 34504
'''
'''
子进程3 is running 46212 parent: 35732
子进程1 is running 1528 parent: 35732
子进程2 is running 50244 parent: 35732
主 35732 parent: 12480
'''
"""
子进程1 is running
子进程2 is running
子进程3 is running
主 5.094129323959351 # 等的是5秒 任然是并发,不是串行。
""" # 多个子进程join方法 串行
from multiprocessing import Process
import time
import os def task(name,n):
print('%s is running'%(name))
time.sleep(n) if __name__ == '__main__':
start = time.time()
p1 = Process(target=task,args=('子进程1',5))
p2 = Process(target=task,args=('子进程2',3))
p3 = Process(target=task,args=('子进程3',2)) p1.start()
p1.join()
p2.start()
p2.join()
p3.start()
p3.join() print('主',(time.time()-start)) # 这个时候就是 串行
"""
子进程1 is running
子进程2 is running
子进程3 is running
主 10.235251665115356
""" # 其他方法:is_alive() terminate() pid name
from multiprocessing import Process
import time
import os def task(name):
print('%s is running'%(name),os.getpid())
time.sleep(2) if __name__ == '__main__':
# p = Process(target=task,args=('子进程1',))
# p.start()
# print(p.is_alive())
# p.join()
# print('主')
# print(p.pid) # 子进程即僵尸进程pid
# print(p.is_alive()) # 查看进程是否还活着 p = Process(target=task,name='sub-process',args=('子进程1',))
p.start()
# p.terminate() # 给os 发了个信号,还没来的及杀死子进程
# time.sleep(2)
# print(p.is_alive()) # True --> 加了time.sleep(2) --> False
print('主') print(p.name,p.pid)
"""

Process-1 48456
子进程1 is running 48456
"""
"""

sub-process 43556
子进程1 is running 43556
"""

4.守护进程

 """
开进程的目的:并发任务;假设任务在主进程死后没意义存在了,就设为守护进程。
守护进程:
0.p.daemon = True
1.主进程结束时,守护进程就完了
2.守护进程一定要在子进程start()前设置
3.不允许在守护进程内在开子进程
"""
from multiprocessing import Process
import time def task(name):
print('%s is running'%name)
time.sleep(2)
# p = Process(target=time.sleep,args=(3,))
# p.start() if __name__ == "__main__":
p = Process(target=task,args=('子进程1',))
p.daemon = True # 守护进程 主结束时,子进程就完了 ,守护进程一定要在子进程start() 前设置
p.start()
p.join()
print('主')
"""

"""
"""
子进程1 is running

""" """练习题:"""
# 思考下列代码的执行结果有可能有哪些情况?为什么?
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-------") # 只要这里一运行,守护进程就完了 """
main-------
456
end456
"""

并发编程 - 进程 - 1.开启子进程的两种方式/2.查看pid/3.Process对象的其他属性或方法/4.守护进程的更多相关文章

  1. 并发编程 - 线程 - 1.开启线程的两种方式/2.进程与线程的区别/3.Thread对象的其他属性或方法/4.守护线程

    1.开启线程的两种方式: 进程,线程: 进程只是用来把资源集中到一起(进程只是一个资源单位,或者说资源集合)而线程才是cpu上的执行单位) 1.同一个进程内的多个线程共享该进程内的地址资源 2.创建线 ...

  2. python 之 并发编程(开启子进程的两种方式,进程对象的属性)

    第九章并发编程 同一个程序执行多次是多个进程 import time import os ​ print('爹是:',os.getppid()) #父进程PID,(pycharm) print('me ...

  3. Java并发编程:线程间协作的两种方式:wait、notify、notifyAll和Condition

    Java并发编程:线程间协作的两种方式:wait.notify.notifyAll和Condition 在前面我们将了很多关于同步的问题,然而在现实中,需要线程之间的协作.比如说最经典的生产者-消费者 ...

  4. 19、Java并发编程:线程间协作的两种方式:wait、notify、notifyAll和Condition

    Java并发编程:线程间协作的两种方式:wait.notify.notifyAll和Condition 在前面我们将了很多关于同步的问题,然而在现实中,需要线程之间的协作.比如说最经典的生产者-消费者 ...

  5. Process 开启子进程 的两种方式、join控制子进程、守护进程

    一.join控制子进程的一种方式 当主进程需要在子进程结束之后结束时,我们需要用到join来控制子进程. import time import random from multiprocessing ...

  6. python 之 并发编程(线程理论,开启线程的两种方式,进程与线程的区别,线程对象的其他方法)

    9.9 线程理论 1.什么是线程 线程指的是一条流水线的工作过程 进程根本就不是一个执行单位,进程其实是一个资源单位,一个进程内自带一个线程,线程才是执行单位 2.进程VS线程 同一进程内的线程们共享 ...

  7. python 并发编程 多线程 开启线程的两种方式

    一 threading模块介绍 multiprocess模块的完全模仿了threading模块的接口,二者在使用层面,有很大的相似性 二 开启线程的两种方式 第一种 每造一个进程,默认有一个线程,就是 ...

  8. 并发编程---Process对象的其他属性或方法

    Process对象的其他属性或方法 #join方法 from multiprocessing import Process import time,os ''' 需求:让主进程等着子进程运行完毕,才能 ...

  9. Python 35 线程(1)线程理论、开启线程的两种方式

    一:线程理论 1 什么是线程 进程其实一个资源单位,而进程内的线程才是cpu上的执行单位 线程其实指的就是代码的执行过程2 为何要用线程   线程vs进程     1. 同一进程下的多个线程共享该进程 ...

随机推荐

  1. vss安装及服务器端、客户端配置图文教程

    安装VSS 一.双击setup. 之后点完成.就安装完了! 服务器端VSS配置 一.选择开始——所有程序——打开 一直下一步  到完成 二.然后再打开 说明:把这个enable rights and  ...

  2. 华中农业大学校赛 I Catching Dogs

    Catching Dogs Time Limit: 1 Sec  Memory Limit: 128 MBSubmit: 1140  Solved: 298[Submit][Status][Web B ...

  3. lodop简单入门教程

    lodop简单入门 1 安装(这个不介绍,下载安装即可) 声明只能装windows,linux不能装,所以linux 服务器要使用直接使用http://localhost:8000/CLodopfun ...

  4. Java反射机制在工厂模式中的应用

    在本篇文章中就不详细介绍工厂模式,主要介绍一下反射在工厂模式中的使用,让读者对反射机制带来的好处有更深的认识. 首先看一下简单工厂模式 简单工厂模式(simple factory)是类的创建模式,又叫 ...

  5. 编译Spark2.1.2源码

    源码编译的shell脚本为 /dev/make-distribution.sh ,下载源码包解压就能找到.不同版本使用的参数有差异.可以直接查看make-distribution.sh文件. 下载sp ...

  6. jquery post 同步异步总结

    最近在测试,发现有些效果不对,最后发现是post的执行顺序问题,所以研究了下,写了以下总结 1.post被请求多次,解决方法: 连接加入随机数 rand=""+Math.rando ...

  7. CMake Error at cmake/boost.cmake:76 (MESSAGE):

    编译mysql5.7.9的时候报错 CMake Error at cmake/boost.cmake:76 (MESSAGE): You can download it with -DDOWNLOAD ...

  8. 关于JDK环境变量的配置问题

    网上配置JDK环境变量的时候一直说要配置三个环境变量,什么JAVA_HOME,Path,CLASSPATH 其实是说以后如果要修改JDK的版本或者路径,只要更改JAVA_HOME就可以了,Path,C ...

  9. 小结:STL

    概要: c++的stl是个神奇的东西,需要好好学习. 技巧及注意: lower_bound是第一个大于等于要查找值 upper_bound是第一个大于要查找的值 stl中的容器中的比较几乎全都用< ...

  10. asp.net 动态添加多个用户控件

    动态添加多个相同用户控件,并使每个用户控件获取不同的内容. 用户控件代码: 代码WebControls using System; using System.Collections.Generic;  ...