Python多任务实现方式(一)-----多进程

前言:众所周知,在当前的计算机中我们可以让其一次性去执行一个乃至多个程序,程序运行时就是计算机对其资源的分配,也就是一个进程,那么进程到底是什么呢?下面本博主就自己的一些理解来与大家分享分享…

进程:

1.进程的概念:

一个正在运行的程序或软件就是一个进程,进程是操作系统进行资源分配的最基本单位,启动一个软件,系统分配一定的内存,进程就是一个程序在一个数据集上的一次动态执行过程。进程一般是由程序、数据集、进程控制块三部分组成的。

2.进程分类:

进程又分为单进程和多进程两种形式:

(1).单进程:

单进程:默认程序开启时创建一个进程,咱们所写的一个py文件就是一个进程,系统会分配资源开启一个进程去处理这个py文件,主线程去执行这个文件

(2).多进程:

完成多任务,每一个进程各自执行各自的任务,各自互不干扰各干各的事儿,本文章主要讲多进程

3.multiprocessing模块:

提起多进程,大家肯定会想到multiprocessing这个模块,是多进程编程必需的模块,multiprocessing 是一个用与 threading 模块相似API的支持产生进程的包, multiprocessing 包同时提供本地和远程并发，使用子进程代替线程

4.Process类:

在 multiprocessing 中，通过创建一个 Process 对象然后调用它的 start() 方法来生成进程
简单的来了解一下Process:

(1).一般格式:

multiprocessing.Process(group=None,target=self,name=self,args=(self,),kwargs={})

(2).Process参数:

• group:指定进程组,一般目前初学者也没有进程组就默认为None;
• target:执行目标任务名;
• name:进程名字;
• args:以元组形式向执行任务传参;
• kwargs:以字典形式向执行任务传参.

(3).Process创建实例对象:

• start():启动子进程实例,也就是创建一个子进程;
• join():等待主进程执行结束,监测主进程完成后,从而再去执行子进程;
• terminate():不管任务是否完成,立即终止子进程.

1.start():

举例:

import multiprocessing   #导包,必需
import time     #导入时间包,监测进程运行时常,并且给予其一定的休息时间

def run(name):
    print(time.time())
    for _ in range(5):
        print(f"我叫{name}在跑步")
        time.sleep(1)
    print("我执行完毕啦")


def sing(name):
    print(time.time())
    for _ in range(5):
        print(f"我叫{name}我在唱歌")
        time.sleep(1)
    print("我执行完毕啦")


run_process=multiprocessing.Process(group=None,target=run,name=None,args=("张三",))
sing_process=multiprocessing.Process(group=None,target=sing,kwargs={"name":"李四"})

if __name__ == '__main__':
	"""进行创建进程"""
    run_process.start()
    # run_process.terminate()
    # run_process.join()
    sing_process.start()
    # sing_process.terminate()

结果:

2.join():

关于join()方法的使用必须在需要join()对象开启后使用,它的通俗含义就是,只有我完成了才能轮到你,我没结束你就不能执行,一直等着去
截取上面部分重要运行代码:

run_process=multiprocessing.Process(group=None,target=run,name=None,args=("张三",))
sing_process=multiprocessing.Process(group=None,target=sing,kwargs={"name":"李四"})
if __name__ == '__main__':
    # print(os.getpid())
    run_process.start()
    # sing_process.daemon=True   #子进程被主进程保护
    # run_process.terminate()
    # os.kill(os.getppid(),9)
    run_process.join()
    sing_process.start()
    # sing_process.terminate()
    # print(multiprocessing.current_process())

那么它的运行结果可想而知,只有当run进程执行完之后,sing进程才会执行:

3.terminate():

terminate()的意思就是强制结束进程,不论你是否在执行是否完成,统一给你就结束了:

run_process=multiprocessing.Process(group=None,target=run,name=None,args=("张三",))
sing_process=multiprocessing.Process(group=None,target=sing,kwargs={"name":"李四"})
if __name__ == '__main__':
    # print(os.getpid())
    run_process.start()
    # sing_process.daemon=True   #子进程被主进程保护
    run_process.terminate()
    # os.kill(os.getppid(),9)
    # run_process.join()
    sing_process.start()
    # sing_process.terminate()
    # print(multiprocessing.current_process())

由结果可以看出,在进程run刚开启时,对其使用terminate()方法,它直接被终止运行,这就是terminate().

(4).常用属性:

name:当前进程别名,默认为Process-N,N为从1开始的递增整数,那么到底是什么意思呢?咱们一起来看看:

run_process=multiprocessing.Process(group=None,target=run,name="张三",args=("张三",))
sing_process=multiprocessing.Process(group=None,target=sing,name="李四",kwargs={"name":"李四"})
if __name__ == '__main__':
    # print(os.getpid())
    run_process.start()
    print(run_process.name)
    # sing_process.daemon=True   #子进程被主进程保护
    # run_process.terminate()
    # os.kill(os.getppid(),9)
    # run_process.join()
    sing_process.start()
    print(sing_process.name)
    # sing_process.terminate()
    # print(multiprocessing.current_process())

进程的名称,这个名称是一个字符串，仅用于识别目的。它没有语义。可以为多个进程指定相同的名称。

5.获取进程编号:

获取进程编号需要导入一个我们比较熟悉的包,os在文件进行操作时,也用到过这个包

(1).作用:

进程编号就是进程在运行时,系统给予,便于验证主子进程之间的关系,得知子进程由哪个主进程创建;

(2).方式:

1. 获取当前进程:os.getpid()
2. 获取父进程:os.getppid()

def run(name):
    print(f"run:{os.getpid()}")
    print(time.time())
    for _ in range(5):
        print(f"我叫{name}在跑步")
        time.sleep(1)
    print("我执行完毕啦")


def sing(name):
    print(f"sing:{os.getppid()}")
    print(time.time())
    for _ in range(4):
        print(f"我叫{name}我在唱歌")
        time.sleep(2)
    print("我执行完毕啦")

6.进程特性;

1. 进程之间不共享全局变量
   一个进程修改了全局变量,其他进程不受影响,每个进程拿到的都是初始的全局变量,全局变量在进程之间相互独立存在,之间没有任何的关系。

import multiprocessing

num = 0

def work1():
    for i in range(10):
        global num   #用于修改全局变量
        num += i
    print(f"我最终的结果是:{num}")

def work2():
    print(f"结果是:{num}")

work1_process = multiprocessing.Process(target=work1)
work2_process = multiprocessing.Process(target=work2)

if __name__ == '__main__':
    work1_process.start()
    work2_process.start()

由上结果可见,当进程work1修改了全局白能量,但是work2拿到的依旧是初始的全局变量

2. 主进程会等所有子进程结束之后再结束
   在主进程结束之前,手动结束子进程,那么程序结束由主进程来进行决定,那么手动结束子进程有两种方式:

1.在主进程结束前,保证所有子进程结束使用:terminate()
2.在子进程开启前,设置子进程被主进程所守护(deamon),那么主进程结束,子进程也就随即结束
第一种方法前文已经提到过,那么看**第二种(deamon)**方法

import multiprocessing

num = 0

def work1():
    for i in range(10):
        global num
        num += i
    print(f"我最终的结果是:{num}")

def work2():
    print(f"结果是:{num}")

work1_process = multiprocessing.Process(target=work1)
work2_process = multiprocessing.Process(target=work2)

if __name__ == '__main__':
    work1_process.start()
    work2_process.daemon=True
    work2_process.start()

注意哦:deamon为bool类型哦