开启一个子进程函数,子进程函数不带参数
from multiprocessing import Process
def func_01():
print('子进程')
if __name__ == '__main__': # 开启多进程 必修有此行代码
# target=要开启的子进程的函数
p = Process(target=func_01) # 实例化一个进程对象
p.start() # 开启一个子进程
print('父进程')
开启一个子进程函数,子进程函数带参数
from multiprocessing import Process
def func_01(a):
print('子进程')
if __name__ == '__main__': # 开启多进程 必修有此行代码
# target=开启这个子进程的函数 args=要传给这个子进程函数的参数 必须为元组类型 本示例随意传递了参数
p = Process(target=func_01, args=(123,)) # 实例化一个进程对象
p.start() # 开启一个子进程
print('父进程')
子进程与父进程同时运行,可通过如下的间隔打印示例看出,其打印结果为"子进程"与"父进程"交替出现,代表子进程与父进程同时运行(多进程)
from multiprocessing import Process
import time
def func_01(a):
for i in range(1, 10, 1):
time.sleep(0.1)
print('子进程')
if __name__ == '__main__': # 开启多进程 必修有此行代码
# target=开启这个子进程的函数 args=要传给这个子进程函数的参数 必须为元组类型 本示例随意传递了参数
p = Process(target=func_01, args=(123,)) # 实例化一个进程对象
p.start() # 开启一个子进程
for i in range(1, 10, 1):
print('父进程')
time.sleep(0.1)
正常情况下 主进程与子进程一同运行.
当使用join() 时,主进程将阻塞住并等待子进程执行完再继续运行下面的代码
如下的代码示例将先打印完全部"子进程",再打印"父进程",而不是交替打印.
from multiprocessing import Process
import time
def func_001():
for i in range(1, 50, 1):
time.sleep(0.05)
print('子进程')
if __name__ == '__main__': # 开启多进程 必修有此行代码
p = Process(target=func_001)
p.start() # 开启一个子进程
p.join() # join() 主进程将阻塞住并等待子进程执行完再继续运行下面的代码
for i in range(1, 50, 1):
time.sleep(0.05)
print('父进程')
os.getpid() 返回当前进程的pid
os.getppid() 返回当前进程的父进程的pid
from multiprocessing import Process
import os
def func_01():
print('子进程的pid:', os.getpid(), '我的父进程的pid', os.getppid())
if __name__ == '__main__': # 开启多进程 必修有此行代码
# target=要开启的子进程的函数
p = Process(target=func_01) # 实例化一个进程对象
p.start() # 开启一个子进程
print('父进程的pid:', os.getpid())
pid可在任务管理器的’进程’中查看,如果没有显示可以通过任务管理器中的相关设置来显示进程的pid
p = Process(target=func_01, name=‘进程01’) 中的
name参数命名一个进程的名字.
p.name方法查看进程的名字
from multiprocessing import Process
def func_01():
print('子进程')
if __name__ == '__main__': # 开启多进程 必修有此行代码
# target=要开启的子进程的函数 name=进程的名字
p = Process(target=func_01, name='进程01') # 实例化一个进程对象
p.start() # 开启一个子进程
print('父进程')
print('进程的名字:', p.name) # 打印进程的名字
.is_alive() 判断进程是否存活 返回布尔型数据
本示例中,子进程运行2秒,父进程运行5秒,第一次判断存活为True,第二次判断存活在5秒后为False.
from multiprocessing import Process
import time
def func_01():
print('子进程')
time.sleep(2)
if __name__ == '__main__': # 开启多进程 必修有此行代码
# target=要开启的子进程的函数 name=进程的名字
p01 = Process(target=func_01, name='进程01') # 实例化一个进程对象
p01.start() # 开启一个子进程
print('子进程func_01是否存活:', p01.is_alive()) # 判断进程是否存活 返回布尔型数据
time.sleep(5)
print('子进程func_01是否存活:', p01.is_alive())
.terminate() 杀死进程
from multiprocessing import Process
import time
def func_01():
time.sleep(200) # 子进程运行200秒
if __name__ == '__main__': # 开启多进程 必修有此行代码
# target=要开启的子进程的函数 name=进程的名字
p01 = Process(target=func_01, name='进程01') # 实例化一个进程对象
p01.start() # 开启一个子进程
print('子进程func_01是否存活:', p01.is_alive()) # 判断进程是否存活
p01.terminate() # 手动杀死子进程
time.sleep(1) # 给计算机杀死进程的工作时间
print('子进程func_01是否存活:', p01.is_alive()) # 判断进程是否存活
.daemon = True 守护进程
守护进程(子进程)会在父进程的代码执行结束后一同结束.
如下的示例,普通情况下’子进程func_01’会在运行完100秒之后才结束,而将其设置为守护进程后(p01.daemon = True ),他会在父进程结束后一同结束.
而且守护进程不可以再拥有属于自己的子进程,
from multiprocessing import Process
import time
def func_01():
time.sleep(100)
print('子进程')
if __name__ == '__main__':
p01 = Process(target=func_01)
p01.daemon = True # 将p进程设置为守护进程 在start之前设置
p01.start()
time.sleep(1)
print('父进程')