开启一个子进程函数,子进程函数不带参数

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('父进程')