[Python知识库]Python进程（多任务）的理解和使用，看这篇就够了

Python学习（进程）

进程（process）

1.概念：

计算机分配资源的最小单位，通俗来讲，一个正在运行的程序即是一个进程。

2.语法/包：

2.1导入进程包

import multiprocessing

通过进程创建进程对象

进程对象 = multiprocessing.Process(target=任务名) 

启动进程执行任务

进程对象.start()

2.2函数需要传入参数时：

在设置进程的函数中传递参数的两种方式

1.元组方式：args = 元组

进程对象 = multiprocessing.Process(target=任务名,arg=元组) 

2.字典方式:kwargs = 字典

进程对象 = multiprocessing.Process(target=任务名,kwarg=字典) 

2.3注意事项：元组中只有一个元素时写成(a,)形式，函数需要多个参数时元组中的元素需和其顺序一致

? 字典中的元素的键需和函数形参的名字一致，顺序可不一致（字典本身就是没有顺序的）

3.案例：

创建一个coding函数和一个music函数，让两个函数在进程下执行

3.1不带参数

import multiprocessing
import time


# 初体验使用multiprocessing

import multiprocessing

# 使用multiprocessing的三个步骤是：
# 1. 导入multiprocessing
# 2.创建实例
# 3.实例去调用start方法即可

# 设置函数
def coding():
    for i in range(3):
        print('coding')
        time.sleep(0.2)
        
def music():
    for i in range(3):
        print('nusic')
        time.sleep(0.2)
        
# 创建实例
coding_process = multiprocessing.Process(target=coding)
music_process = multiprocessing.Process(target=music)
        
def main():        
    # 开启进程
    coding_process.start()
    music_process.start()

if __name__ == '__main__':
    main()
    

3.2带参数

import multiprocessing
import time
from unicodedata import name

# 在设置进程的函数中传递参数的两种方式
# 1.元组方式：args = 元组
# 2.字典方式:kwargs = 字典
# 注意事项：元组中只有一个元素时写成(a,)形式，函数需要多个参数时元组中的元素需和其顺序一致
#         字典中的元素的键需和函数形参的名字一致，顺序可不一致（字典本身就是没有顺序的）

# 设置函数
def coding(num,name):
    for i in range(num):
        print(name)
        print('coding')
        time.sleep(0.2)
        
def music(num,name):
    for i in range(num):
        print(name)
        print('music')
        time.sleep(0.2)
        
# 创建实例
coding_process = multiprocessing.Process(target=coding,args=(3,'翔宇'))
music_process = multiprocessing.Process(target=music,kwargs={'num':3,'name':'我是music'})
        
def main():        
    # 开启进程
    coding_process.start()
    music_process.start()

if __name__ == '__main__':
    main()

4.获取进程编号

4.1进程编号的作用：想像一下，当一个运行的程序中有许多个进程时，别说我们想找到某一个进程，就连主进程和子进程我们都可能分不清，所以这个时候最好的方式就是获取他们的编号，以编号来区分。

获取当前进程的编号

os.getpid()

获取父进程的编号

os.getppid()

5.全局变量在子进程之间不共享

5.1全局变量在各子进程之间是不共享的，举例：

定义一个为列表的全局变量glb_list，再创建两个子进程write_process和read_process，write_process用于在glb_list中添加元素，read_process用于读取glb_list，我们发现，在write_process添加元素之后再用read_process去读取glb_list,但结果是读取的glb_list并没有改动。

代码实现:

# 创建一个全局变量
import multiprocessing
import time


glb_list = [3]

def write():
    for i in range(3):
        glb_list.append(i)   # 添加元素
    print(glb_list)

def read():
    print(glb_list)


# 主程序
def main():
    # 创建两个进程
    # 写进程
    write_process = multiprocessing.Process(target=write)
    read_process = multiprocessing.Process(target=read)
    # 读进程
    write_process.start()  # 开启进程
    time.sleep(3)  # 等待写入完毕再读，休眠3秒
    read_process.start()
    time.sleep(3)   
    print(glb_list)  # 打印全局变量



if __name__ == '__main__':
    main()
 
out:
[3, 0, 1, 2]
[3]
[3]

6.主进程和子进程的结束顺序

在我们正在用QQ聊天，这时候qq的app相当于是主程序，而聊天窗口为子程序，当我们关闭app后，聊天窗口也会关闭。因此对于常识来看，当我们结束主进程之后，子进程也会立即被结束。但是实际上，我们的主程序结束子进程时，主进程会等待子进程执行完毕才结束。那么真的是这样吗，怎样实现在主进程结束的同时子进程也结束执行呢？

6.1验证：主程序结束子进程时，主进程会等待子进程执行完毕才结束

代码：

import multiprocessing
import time


def test():
    for i in range(5):
        print('子程序执行中~~~~')

# 主程序
def main():
    # 创建子进程
    test_process = multiprocessing.Process(target=test)
    # 开启子进程
    test_process.start()
    # 如果子程序还在执行，打印这句话后下面还有输出“子程序执行中~~~~“
    print('主程序在此结束，如果下面还有东西，说明子进程还在执行')  


if __name__ == '__main__':
    main()
    
out：
主程序在此结束，如果下面还有东西，说明子进程还在执行
子程序执行中~~~~
子程序执行中~~~~
子程序执行中~~~~
子程序执行中~~~~
子程序执行中~~~~

6.2实现主进程结束的同时子进程也结束执行

6.2.1将子进程设置成守护进程

其一：守护进程会在主进程代码执行结束后就终止

其二：守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children

语法：子进程.daemon = True

代码：

import multiprocessing
import time


def test():
    for i in range(10):
        print('子程序执行中~~~~')

# 主程序
def main():
    # 创建子进程
    test_process = multiprocessing.Process(target=test)
    # 设置守护进程
    test_process.daemon = True  # 需要在开启前设置
    # 开启子进程
    test_process.start()
    # 主进程快要结束之前
    print('主程序在此结束，我下面没有东西，说明子进程没有执行了')  


if __name__ == '__main__':
    main()
    
out:
主程序在此结束，我下面没有东西，说明子进程没有执行了

6.2.2在主进程结束前直接终止子进程的执行

语法：子进程.terminate()

参考示例代码：

# import multiprocessing
# import time


# def test():
#     for i in range(10):
#         print('子程序执行中~~~~')

# # 主程序
# def main():
#     # 创建子进程
#     test_process = multiprocessing.Process(target=test)
#     # 设置守护主进程
#     test_process.daemon = True
#     # 开启子进程
#     test_process.start()
#     # 主进程快要结束之前
#     print('主程序在此结束，我下面没有东西，说明子进程没有执行了')  


# if __name__ == '__main__':
#     main()
    
    
    
## 在主进程结束前直接终止子进程的执行

import multiprocessing
import time


def test():
    for i in range(10):
        print('子程序执行中~~~~')

# 主程序
def main():
    # 创建子进程
    test_process = multiprocessing.Process(target=test)
    # 开启子进程
    test_process.start()
    # 主进程快要结束之前断掉子进程的执行
    test_process.terminate()
    print('主程序在此结束，我下面没有东西，说明子进程没有执行了')  


if __name__ == '__main__':
    main()
    
out:
主程序在此结束，我下面没有东西，说明子进程没有执行了

多任务就总结到这里了，欢迎大家点赞转发！

参考：1.https://www.bilibili.com/video/BV1Ex411x7Xn?p=37&vd_source=7f9a498048cacd0bd5f2c900fa2c44d6

2.https://blog.csdn.net/Python_0011/article/details/124822629