8-1-1python语法基础-并发编程-进程-进程创建

前言

先看这个文章：
python进程，线程，协程，对比，思考： https://www.cnblogs.com/andy0816/p/15590085.html

Python中使用多进程

• 运行中的程序就是一个进程。所有的进程都是通过它的父进程来创建的。
• 因此，运行起来的python程序也是一个进程，那么我们也可以在程序中再创建进程。
• 多个进程可以实现并发效果，就会让程序的执行速度变快。
• 多进程有一个内置的模块，我们需要借助这个模块：
• from multiprocessing import Process

multiprocessing模块

• 在这个包中几乎包含了和进程有关的所有子模块。由于提供的子模块非常多，为了方便大家归类记忆，
• 我将这部分大致分为四个部分：
• 1，创建进程部分，
• 2，进程同步部分，
• 3，进程池部分，
• 4，进程之间数据共享。

进程类Process的常用方法如下：

• 1 start() 创建一个Process子进程实例并执行该实例的run()方法
• 2 run() 子进程需要执行的目标任务
• 3 join() 主进程阻塞等待子进程直到子进程结束才继续执行，可以设置等待超时时间timeout
• 4 terminate() 终止子进程
• 5 is_alive() 判断子进程是否终止
• 6 daemon 设置子进程是否随主进程退出而退出

创建进程

创建进程的方式1，通过构造函数的方式

创建单个进程

import multiprocessing, os


def hi(arg):
    print(arg)
    print("父进程号", os.getppid(), "子进程号", os.getpid())


if __name__ == '__main__':
    p = multiprocessing.Process(target=hi, args=("xiaoxiao",))
    p.start()
    p.join()
    print("end")

• 认知这个多进程：
• 1，python里面的多进程是使用的标准库，import multiprocessing，实现的
• 2，一定要在main函数下进行创建进程
• 3，multiprocessing.Process()这一步还没有创建子进程，只是一个子进程的实例，
• 3，p.start()：启动进程，并调用该子进程中的p.run()，这一步子进程才真正的创建并启动了，
• 4，p.join()，这个join就是在感知一个子进程的一个结束，将异步改成同步，主进程必须要等待子进程结束之后，才会结束，如果不加，主进程就会先结束，
• 5，注意参数的传递，args是传递一个元组，一个元素的时候要有逗号，kargs是传递一个字典，参数可以不传，

创建多个进程：

from multiprocessing import Process
import time


def task(name):
    print('{} is running!'.format(name))
    time.sleep(3)
    print('{} is done!'.format(name))


if __name__ == '__main__':
    # 开启10个子进程
    p_list = []
    for i in range(10):
        p = Process(target=task, args=(i, ))
        p_list.append(p)
        p.start()
    # p.join()
    [p.join() for p in p_list]  # 保证前面的10个进程全部结束了，才会执行下面的代码，
    print('--- 主进程 ----')
    # 这种开启了多进程，可以读多个进程去存文件，取文件内容，

创建进程的方式2：通过类的方式

• 注意两点
• 第一点，创建一个类，继承Process
• 第二点，类中必须实现run方法，这个run方法里面就是子进程要执行的内容，

import os
from multiprocessing import Process

class MyProcess(Process):  # 继承导入的process，
    def __init__(self,name):  # 为了进程能传递参数，
        super().__init__()  # 这是继承了父类所有的参数，
        self.name=name
    def run(self):
        # print(os.getpid())
        print("子进程号",self.pid)
        print("参数",self.name)  # print(os.getpid()) 这两句是一样的，


if __name__ == '__main__':
    # p1=MyProcess()  # 这是不传参数的
    p1=MyProcess("name1")  # 这是传参数的，这就是面向对象的实例化，
    p2=MyProcess('name2')
    p3=MyProcess('name3')

    p1.start() #start会自动调用run
    p2.start()
    # p2.run()
    p3.start()
    # 三个进程之间是异步的，

    p1.join()
    p2.join()
    p3.join()
    # 三个进程都结束了才会执行下面的内容，这是把异步，变成同步
    print('主线程')

进程的其他方法

from multiprocessing import Process
import time
def func(name):
    print("%s在test...."%name)

if __name__ == "__main__":
    p = Process(target=func,args=("andy",))
    p.start()
    print(p.is_alive())  # # 判断一个进程是否活着
    p.terminate()  # 结束一个进程，
    time.sleep(1)
    print(p.is_alive())