Day033--Python--进程

什么是进程?

　　进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。我们自己在python文件中写了一些代码，这叫做程序，运行这个python文件的时候，这叫做进程。

 子进程内不能有input(), 没有给进程准备输入框

创建进程的第一种方式:

import time
import os
from multiprocessing import Process

def func1(n):
    time.sleep(1)
    print(n)

def func2(n):
    time.sleep(1)
    print(n)

def func3(n):
    time.sleep(1)
    print(n)

def func4(n):
    time.sleep(1)
    print(n)

if __name__ == '__main__':
    p1 = Process(target=func1, args=(1,))
    p2 = Process(target=func2, args=(2,))
    p3 = Process(target=func3, args=(3,))
    p4 = Process(target=func4, args=(4,))
    p1.start()
    p2.start()
    p3.start()
    p4.start()

    print('主进程结束了')

创建进程的第二种方式:

import os
from multiprocessing import Process

class MyProcess(Process):    # # 自己定义一一个Process类
    def __init__(self, n, name):
        super().__init__()       # 执行父类的__init__(). 此处必须调用Process的__init__方法
        self.n = n
        self.name = name

    def run(self):                      # 必须写run方法
        print('看看我是n>>>', self.n)
        print('子进程pid', os.getpid())
        print('我是run')

if __name__ == '__main__':
    p1 = MyProcess(100, name='子进程')
    p1.start()               # 通知操作系统创建进程, 子进程创建好之后等待被执行,执行的时候调用run方法  
    print('p1.pid', p1.pid)
    print('p1.name', p1.name)
    print('主进程结束')

如果进程不在 if __name__ == '__main__': 中运行,则会报错:    (Windows系统下)

    An attempt has been made to start a new process before the current process has finished its bootstrapping phase.
    This probably means that you are not using fork to start your child processes and you have forgotten to use the 
proper idiom in the main module:
　　　　 　　if __name__ == '__main__':
　　　　　　　　freeze_support()
　　　　　　　　...
    The "freeze\_support()" line can be omitted if the program is not going to be frozen to produce an executable.

为什么一定要用__main__ ?

由于Python运行过程中，新创建进程后，子进程会copy一遍主进程中所有的东西. 代码在运行到p1.Process时，新的进程会重新读入该代码，
对于没有if __name__=="__main__"保护的代码，新进程都认为是要再次运行的代码，这时子进程又一次运行p1.Process，
但是在multiprocessing.Process的源码中是对子进程再次产生子进程是做了限制的，是不允许的，于是出现如上的错误提示。

验证空间隔离
两种传参方式:

global_num = 100

def func1(n):
    global global_num
    global_num = n
    print('子进程中global_num>>>', n)

if __name__ == '__main__':
    p1 = Process(target=func1, args=(1,))
    p1.start()
    time.sleep(1)     # 证明进程之间是空间隔离的
    print('全局变量', global_num)
    print('主进程结束')

global_num = 100

def func1(n):
    global global_num
    global_num = n
    print('子进程中的global_num', global_num)

if __name__ == '__main__':
    p1 = Process(target=func1, kwargs={'n':1})   # key必须和func1的形参保持一致
    p1.start()
    time.sleep(1)
    print('全局变量global_num', global_num)
    print('主进程结束')

join()方法: 等待子进程执行结束后再继续往下运行

global_num = 100
def func(n):
    global global_num
    global_num = n
    time.sleep(2)
    print('子进程全局变量>>>', global_num)

if __name__ == '__main__':
    p1 = Process(target=func, kwargs={'n': 1})
    p1.start()
    print('子进程执行中...')
    p1.join()   # 子进程执行完毕后才继续执行下面的
    print('主进程全局变量', global_num)

验证并发进程运行时间:

def func1(n):
    time.sleep(n)
    print('func1')
def func2(n):
    time.sleep(n)
    print('func2')
def func3(n):
    time.sleep(n)
    print('func3')

if __name__ == '__main__':
    p1 = Process(target=func1, args=(1,))
    p2 = Process(target=func2, args=(2,))
    p3 = Process(target=func3, args=(3,))
    p1.start()
    p2.start()
    p3.start()

创建进程的for循环应用:

如果执行多进程, 如何让主进程等待所有进程运行结束:

def func(n):
    print(n)

if __name__ == '__main__':
    for i in range(100):  # for循环也会占用时间,因此'主进程结束'可能在前面,也可能往后移
        p = Process(target=func, args=(i,))
        p.start()

    print('主进程结束')

# 循环下的多进程,如何用join方法
def func(n):
    print(n)

if __name__ == '__main__':
    lst = []
    for i in range(100):
        p1 = Process(target=func, args=(i,))
        p1.start()
        lst.append(p1)

    for p in lst:
        p.join()
    # p1.join()   # 放在这的话p1只能是i=99的进程, 而此进程的执行顺序不一定在最后
    print('主进程结束')

terminate 和 is_alive

def func():
    print('子进程')

if __name__ == '__main__':
    p1 = Process(target=func)
    p1.start()
    p1.terminate()  # 给操作系统发送了一个关闭p1进程的信号, 关闭进程
    # time.sleep(1)   # 这个时间内进程已经关闭了
    print('看子进程是否还运行着:', p1.is_alive())  # 此时系统还没来得及关闭
    print('主进程结束')

僵尸进程和孤儿进程

def func():
    print(os.getpid())
    print('子进程')

if __name__ == '__main__':
    p1 = Process(target=func,)
    p1.start()
    p1.join()
    print('子进程是否还活着:', p1.is_alive())
    print(p1.pid)    # 已经死了,但是还有pid, 僵尸进程,一直存在会有害
    print('主进程结束')
    # 在子进程结束之前, 主进程会等待,不会结束,等着回收僵尸进程

　　如果强行把主进程关闭掉,而子进程还在运行,那子进程就变成了孤儿进程,由操作系统负责回收

守护进程:

def func():
    time.sleep(5)
    print('子进程', os.getpid())

if __name__ == '__main__':
    p1 = Process(target=func)
    p1.daemon = True   # 设置守护进程, 当主进程结束时全部子进程立即结束
    p1 .start()print('主进程结束')
# 此时主进程一结束, 子进程也立即结束,连pid都没来得及打印