Day033--Python--进程-Python开发

子进程内不能有input(), 没有给进程准备输入框创建进程的第一种方式:import timeimport osfrom multiprocessing import Processdef func1(n):time.sleep(1)print(n)def func2(n):time.sleep(1)print(n)def func...

子进程内不能有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__': 中运行,则会报错:

    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('主进程结束') # 在子进程结束之前, 主进程会等待,不会结束,等着回收僵尸进程

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

守护进程: