python 多任务之多进程

多任务

优势

多个任务同时执行可以大大提高程序执行效率，可以充分利用CPU资源，提高程序的执行效率

概念

是指在同一时间内执行多个任务

多进程

概念

进程（process）是资源分配的最小单位，他是操作系统进行资源分配和调度运行的基本单位，比如：一个正在运行的程序就是一个进程，如QQ，微信等

一个程序的运行至少有一个进程，在程序运行后，默认会创建一个进程，称之为主进程，在主进程里面创建的进程，称之为子进程

进程的创建步骤

1.导入进程所需要的包
import multiprocessing

2.通过进程类创建进程对象
进程对象 = multiprocessing.Process(target=任务名)

3.启动进程
进程对象.start()

多进程的使用

import multiprocessing
import time

def eat():
    for i in range(10):
        print('正字吃饭=============')
        time.sleep(0.5)        # 等待0.5秒后再执行


def music():
    for i in range(10):
        print('正在唱歌=============')
        time.sleep(0.5)       # 等待0.5秒后再执行


if __name__ == '__main__':
    eat_process = multiprocessing.Process(target=eat,)
    music_process = multiprocessing.Process(target=music,)

    eat_process.start()
    music_process.start()

运行结果

进程执行任务函数的传参

• 元组方式传参：元组方式传参一定要和参数的顺序保持一致
• 字典方式传参：字典方式传参字典中的key一定要和参数名保持一致

import time
import multiprocessing

def eat(num, name):
    for i in range(num):
        print(f'{name}正字吃饭=============')
        time.sleep(0.5)  # 每隔0.5秒执行一次

def music(num, name):
    for i in range(num):
        print(f'{name}正在唱歌=============')
        time.sleep(0.5)  # 每隔0.5秒执行一次

if __name__ == '__main__':
    # 放在元组里面和传进去的参数一一对应，后面一定得加逗号
    eat_process = multiprocessing.Process(target=eat, args=(5, '张三'))
    # 放在字典里面是键值对形式，必须和传进入的参数名字一样，变量名一样
    music_process = multiprocessing.Process(target=music, kwargs={'num': 5, 'name': '张三'})

    eat_process.start()
    music_process.start()

执行结果

获取进程编号和杀死进程

作用：当程序中的进程数量很多，编号就是用来区分主进程和不同的子进程，进行有效的进程管理

获取进程编程的两种方式

1.获取当前进程编号，os.getpid()
import os
print('当前进程编号是：', os.getpid())

2.获取当前父进程编号，os.getppid()

import os
print('当前进程的父进程编号是：', os.getppid())

执行结果 

杀死进程kill

根据进程编号杀死指定进程

os.kill(进程编号, 9)

import os
import multiprocessing
import time

def work():
    # 查看当前进程
    current_process = multiprocessing.current_process()
    # 获取当前进程的编号
    print('work进程编号：', current_process.pid, os.getpid())
    # 获取父进程的编号
    print('work父进程的编号：', os.getppid())
    for i in range(20):
        print('正在工作=============')
        time.sleep(0.5)
        # 根据进程编号杀死对应的进程
        os.kill(os.getpid(), 9)

work()

执行结果

当第16行代码是这个的话   os.kill(os.getppid(), 9)    会怎么样呢？

程序会在执行一次print后，直接退出整个pycharm

管理不同的进程

import multiprocessing
import os

def eat():
    print('这是吃饭的进程的编号===', os.getpid())
    print('这是吃饭的父进程的编号===', os.getppid())

def music():
    print('这是唱歌的进程的编号===', os.getpid())
    print('这是唱歌的父进程的编号===', os.getppid())

if __name__ == '__main__':
    # 获取主进程的编号
    print('这是主进程的编号====', os.getpid())
    print(end='\n')

    eat_process = multiprocessing.Process(target=eat,)
    music_process = multiprocessing.Process(target=music,)

    eat_process.start()
    music_process.start()

执行结果

进程之间不共享全局变量

import time
import multiprocessing

def write_date():
    for i in range(3):
        my_list.append(i)
    print('这是子进程写入的表：', my_list)

def read_date():
    print('这是子进程读数据', my_list)


my_list = []

if __name__ == '__main__':

    write_process = multiprocessing.Process(target=write_date)
    read_process = multiprocessing.Process(target=read_date)

    write_process.start()
    # 主进程等待写入进程执行完成以后代码，再继续往下执行
    time.sleep(1)
    read_process.start()     # 这里是读不出来的，因为进程之间不共享全局变量

    print('这是主进程的：', my_list)     # 这里也是输出不了，只是三个变量名一样，但不是操作同一个全局变量

执行结果

守护主进程和销毁子进程

主进程会等待所有的子进程执行结束再结束

为了保证子进程能够正常运行，主进程会等待所有的子进程执行完成以后再销毁，设置守护主进程的目的是主进程退出子进程销毁，不让主进程再等待子进程去执行

两种方式都能保证主进程退出子进程销毁

        1、设置守护主进程：子进程对象.daemon = True
        2、销毁子进程：子进程对象.terminate()

import multiprocessing
import time

def eat():
    for i in range(10):
        print('正在吃饭==============')
        time.sleep(0.5)

if __name__ == '__main__':
    # 创建子进程
    eat_process = multiprocessing.Process(target=eat,)
    # 启动子进程
    eat_process.start()
    time.sleep(1)
    print('主进程执行完毕==========')

执行结果 

设置守护主进程

import multiprocessing
import time

def eat():
    for i in range(10):
        print('正在吃饭==========')
        time.sleep(0.5)

if __name__ == '__main__':

    eat_process = multiprocessing.Process(target=eat,)
    # 设置守护主进程，主进程退出后子进程直接销毁，不再执行子进程中的代码
    # 设置守护主进程必须在启动子进程之前
    eat_process.daemon = True
    eat_process.start()

    # 让主进程等待一秒
    time.sleep(2)
    print('主进程执行完毕========')

执行结果

销毁子进程

import multiprocessing
import time

def eat():
    for i in range(10):
        print('正在吃饭==========')
        time.sleep(0.5)

if __name__ == '__main__':

    eat_process = multiprocessing.Process(target=eat,)
    eat_process.start()

    # 让主进程等待一秒
    time.sleep(2)
    # 手动结束子进程，这个方式要写在开启子进程的下面
    eat_process.terminate()

    print('主进程执行完毕========')

执行结果