day28_代码验证

目录

• 1、创建进程的两种方式
  • 1.0 windows与linux/mac的区别
  • 1.1 定义一个任务
  • 1.2 自定义一个类，并继承Process
• 2、join的作用
• 3、进程之间的关系
  • 3.1 进程数据
  • 3.2 进程对象属性
    • 3.2.1 获取子进程号
    • 3.2.2 cmd中查看进程号
    • 3.2.3 进程号的两种回收两件
    • 3.2.4 实例演示
• 4、守护进程

1、创建进程的两种方式

1.0 windows与linux/mac的区别

windows下：创建子进程，windows会将当前父进程代码重新加载执行一次，所以在windows下，实例化进程对象一般放在if __name__ == '__main__':下，以此来规避掉重用问题

linux/mac下：创建子进程，会将当前父进程代码重新拷贝一份，再去执行

1.1 定义一个任务

import time
from multiprocessing import Process


def task(name):
    print(f'{name}的任务开始执行')
    time.sleep(1)
    print(f'{name}的任务已经结束')


# 在linux/mac系统下不会报错
# p = Process(target=task,args=('json',))

if __name__ == '__main__':
    # target=执行函数的地址，即函数对象
    p = Process(target=task, args=('jason',))
    # 向操作系统提交创建进程的任务
    p.start()
    print('主进程')

1.2 自定义一个类，并继承Process

import time
from multiprocessing import Process

class MyProcess(Process):
    # 父类的方法
    def run(self):
        print('任务开始执行')
        time.sleep(1)
        print('任务已经结束')
        
if __name__ == '__main__':
    p = MyProcess()
    p.start()
    print('主进程')

2、join的作用

用来告诉操作系统，等子进程p结束后再执行下面的主进程代码

import time
from multiprocessing import Process


def task(name):
    print(f'{name}的任务开始执行')
    time.sleep(1)
    print(f'{name}的任务已经结束')


# 在linux/mac系统下不会报错
# p = Process(target=task,args=('json',))


if __name__ == '__main__':  
    # target=执行函数的地址，即函数对象，实例化得到一个进程对象
    p = Process(target=task, args=('jason',))
    p1 = Process(target=task,args=('tank',))
    # 向操作系统提交创建进程的任务
    p.start()  # 告诉操作系统，开启子进程p
    p.join()  # 告诉操作系统，等子进程p结束后再执行下面的主进程代码
    print('子进程p结束，开始执行p后的主进程代码')
    
    p1.start()
    print('主进程')

3、进程之间的关系

3.1 进程数据

进程间数据是相互隔离的，主进程与子进程会产生各自的名称空间

from multiprocessing import Process
import time

x = 10
def func():
    print('执行func函数')
    global x
    x= 20
    print(f'进程p的x:{x}')
    time.sleep(1)


if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    p.join()
    print(f'主进程的x:{x}')

3.2 进程对象属性

3.2.1 获取子进程号

current_process().pid

3.2.2 cmd中查看进程号

tasklist |findstr

3.2.3 进程号的两种回收两件

1.join(),可以回收子进程与主进程。

2.主进程正常结束，子进程与主进程也会被回收

3.2.4 实例演示

from multiprocessing import Process
from multiprocessing import current_process
import os
import time

def task(naem):
    print(f'{name} start...',current_process().pid)
    time.sleep(1)
    print(f'{name} over...',current_process().pid)

if __name__ == '__main__':
    p = Process(target=task,args=('jason',))
    p.start()
    
    # 判断子进程是否存活
    print(p.is_alive())
    
    # 直接告诉操作系统，终止子程序p
    p.terminate()
    time.sleep(0.1)  # 等待程序被终止
    
    # 判断子进程是否存活
    print(p.is_alive())
    p.join()
    
    # 获取当前进程的进程号，可以在cmd中使用 'tasklist |findstr 进程号'命令查看验证 
    print('主进程',os.getpid())
    
    # 获取主进程的主进程的进程号
    print('主主进程',os.getppid())
    
    

4、守护进程

from multiprocessing import Process
from multiprocessing import current_process
import time


def task(name):
    print(f'{name} start...', current_process().pid)
    time.sleep(1)
    print(f'{name} over...', current_process().pid)

    print('管家{name}')


if __name__ == '__main__':
    p1 = Process(target=task, args=('jason',))

    # 添加守护进程
    p1.daemon = True  # True代表该进程是守护进程，必须在start之前设置
    p1.start()

    time.sleep(1)
    print('主进程over')
# 输出结果表明，不管子进程有没有执行完毕，只要主进程结束，子进程就会结束    
'''
jason start... 12476
主进程over'''