multiprocessing模块创建子进程

Posted 2021-12-13 dugd

使用multiprocessing模块创建子进程有两种方法

1.用Process类创建子进程对象，然后用start（）方法调用

from multiprocessing import Process
import time

def task():
    print(‘son run‘)
    time.sleep(5)
    print(‘son over‘)


if __name__ == ‘__main__‘:
    p=Process(target=task)  创建子进程对象参数target=函数名
    time.sleep(1)　　　　
    p.start()　　　　　　调用子进程对象
    time.sleep(2)
    print(‘over‘)

==》son run
　　over
　　son over

2.创建父类为Process的类，在自定义的类中创建一个run方法，生成自定义类的对象为进程对象

class Myprocess(Process):
    def __init__(self,name,s):　　需要传入的参数可以根据需求设置
        super().__init__()
        self.name=name
        self.s=s
    def run(self):　　　　run方法会自动被作为进程程序调用
        print(‘%s run‘%self.name)
        time.sleep(self.s)
        print(‘%s over‘%self.name)



if __name__ == ‘__main__‘:
    p=Myprocess(‘aaa‘,1)
    p1=Myprocess(‘bbb‘,3)
    p.start()
    p1.start()

==》bbb run
　　aaa run
　　aaa over
　　bbb over

注意

运行子进程需要在if __name__ == ‘__main__‘:包裹下才能正常运行
创建的进程必须通过start方法来调用才会开始运行，也就是说子啊不被调用的情况下就

不会被执行

进程内存相互隔离

父进程和子进程在运行中内存是被隔离开的，不同的进程在运行时会被放在单独的内存中空间中运行

n=10
def fun():
    n=0
    print(‘son:n=%s‘%n)


if __name__ == ‘__main__‘:
    p=Process(target=fun)
    print(‘far:n=%s‘%n)
    p.start()

==》far:n=10
　　son:n=0

Prscess常用方法和属性

 

p.join() 用来等待子进程结束

class Myprocess(Process):
    def __init__(self,name):
        super().__init__()
        self.name=name

    def run(self):
        print(‘%s run‘%self.name)
        time.sleep(2)　　　　　　测试：子进程运行需要2-3秒
        print(‘%s over‘%self.name)



if __name__ == ‘__main__‘:
    p=Myprocess(‘aaa‘)
    p.start()
    p.join(3)   　　　　　　join参数中传入等待时间，单位是秒
    print(‘start‘)

==》
aaa run
aaa over
start
等待是让父进程等待子进程，等待适当的时间让子进程完成运行

 

p.terminate()  # 终止进程
print(p.name)  # 进程的名称
print(p.is_alive()) #是否存活
p.terminate() # 与start一样 都是给操作系统发送指令 所以会有延迟

print(p.pid)　　查看父进程编号
print(p.exitcode)　＃　获取退出码