进程的创建与方法

目录

• 进程的创建2种方式
  • 两种创建方式的区别
  • 小陷阱
• 进程之间的空间隔离
• 进程其他属性(进程pid)
• 进程对象join方法

进程的创建2种方式

第一种 利用python中模块Process类创建 通过调用multiprocessing模块下面的Process类方法

from multiprocessing import Process
def task(name):
    print('这是我自己定义的函数')
    print(name)
if __name__ == '__main__':
    p=Process(target=task,args=(('参数-name',)))#target对应的是函数名 args必须对应的是元祖
    p.start()
    print('我是主进程')
    
# 遇到的问题
# 为什么主进程永远比子进程快？
# 因为子进程创建需要时间
# p是什么 p.start()又是什么
# p是你实列化出来的一个对象 pstart()是发出这个命令开启子进程 子进程的创建必须依赖与主进程
# 他会完全copy一份数据到子进程空间

第2种 自己定义一个类 继承与Process 重写run 方法 run方法里面是自己写的逻辑代码 方式二借助process类，自定义一个类（继承Process），从而造一个对象 并重新run方法

from multiprocessing import Process
class MYprocess(Process):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        print(666)
        print(self.name)
if __name__ == '__main__':
    p=MYprocess('sq')
    p.start()
    print('主进程')
    
# 为什么为定义name 打印的是 MYprocess-1 ？
# 因为引用了 Process 类中的name
# 如果想要自己传参 为啥自己定义def __init__(self,name):还会报错？
# 因为Process类中的有些东西我们要用到所以不可以覆盖他 我们利用super().__init__()
# 既运行父类__init__还运行 自己的init

两种创建方式的区别

小陷阱

会copy主空间资源
from multiprocessing import Process
x = 1
def task():
    global x
    x=66
    print(x)
print(f'----------------{x}')
if __name__ == '__main__':
    p=Process(target=task,args=(()))
    p.start()
    p.join()
    print(f'{x}--------------')
    
    
打印
----------------1
----------------1
66
1--------------

进程之间的空间隔离

# 我们定义一个全局变量（不可变的 str 可变的list），让其子进程进行修改
# 观察其现象，发现 进程之间的空间隔离 子进程是完全复制一份到子空间 也不同与深ccpy 因为id不同
from multiprocessing import Process
name='骚强'
l1=['骚强']
def task():
    global name
    global l1
    name='你会变'
    l1.append('believe')
    print(f'子进程name  {name} id{id(name)}')
    print(f'子进程 l1  {l1} id {id(l1)}')
if __name__ == '__main__':
    p=Process(target=task,args=(()))#target对应的是函数名 args必须对应的是元祖
    p.start()
    p.join()
    print(f'主进程name  {name} id{id(name)}')
    print(f'主进程 l1  {l1} id {id(l1)}')

进程其他属性(进程pid)

p = Process(target=task,args=('骚强',),name='alex')  # name是进程名
# p.terminate()  # 杀死子进程  ***
# print(p.is_alive())   # ***判断是否存活
# print(p.name)#进程名 不可以在任务打印 只可以主线程
# print(f'子进程:{os.getpid()}')
# print(f'主进程:{os.getppid()}')
终端获取pid
tasklist
tasklist| findstr 进程名

实列

from multiprocessing import Process
import time
import os
def task(name):
    print(44)
    print(f'------------------{name}')
    print(f'子进程:{os.getpid()}')
    print(f'主进程:{os.getppid()}')

if __name__ == '__main__':
    p=Process(target=task,args=(('传参1',)),name='线程名')
    p1=Process(target=task,args=(('传参2',)))
    p.start()
    p1.start()
    print(p.name)
    print(p1.name)

进程对象join方法

join让主进程等待我这个 进程结束之后,在执行主进程. 相当与阻塞
from multiprocessing import Process
import time
def task1():
    print(f'我是task1 我睡了1秒')
    time.sleep(1)
def task2():
    print(f'我是task2 我睡了2秒')
    time.sleep(2)
def task3():
    print(f'我是task3 我睡了3秒')
    time.sleep(3)
if __name__ == '__main__':
    start_time=time.time()
    p1=Process(target=task1,args=(()))
    p2=Process(target=task2,args=(()))
    p3=Process(target=task3,args=(()))
    p1.start()
    p1.join()
    p2.start()
    p2.join()
    p3.start()
    print(f'主进程运行完了 总时间{time.time()-start_time}')