10_python进程

1. 并发：多个进程同时在执行，如执行python文件时，启动多个进程，操作系统管理多个进程；

       1> 同步： 可以理解成在多条车道(进程/线程)上，就只有一辆车在开，按代码的逻辑分支先在A车道跑，之后再走到B车道...

        2> 异步： 可以理解成在多条车道上，有多辆车在开，各自路各自的

        3> os.getpid()：查看当前进程的进程号；

        4> os.getppid())：查看当前进程的父进程号；

        5> 以下代码进程的生命周期：

              a> 主进程开启子进程后，主进程执行自己后面的代码；

              b> 而子进程等到操作系统调度后执行自己的代码；

               c> 此时主进程和子进程都是在各自执行自己的代码 -- 异步；

               e> 子进程执行时间长时，主进程会在主进程代码执行完毕后等待子进程执行完毕之后，主进程才会结束；

import os
import time
from multiprocessing import Process
def func():
    print('子进度启动...')
    time.sleep(2)
    print('子进程id:',os.getpid())  #查看当前进程的进程号
    print('子进程的父进程：', os.getppid())
    print('子进度结束...')

if __name__ == '__main__':
    print('执行当前脚本的进程(父进程)，开始：',os.getpid())
    p = Process(target=func)  #注册
    p.start()    #启动一个子进程，func方法在该子进程中执行
    print('执行当前脚本的进程(父进程)，结束：',os.getpid())
    print('父进程的父进程id：',os.getppid())  # 查看当前进程的父进程，即pycharm工具的进程id
    # 从执行打印出来的信息可见， 主进程启动后，注册了一个子进度，没有等子进程启动执行func方法，就去执行自己的代码
    # 子进程从就绪状态到执行状态，执行代码后，结束子进程
    # 故主进程和子进程是异步的，不是同步的

        6> 带参数启动多进程： p = Process(target=func,args=('参数1','参数2'))

import os
import time
from multiprocessing import Process

def func(*args):
    print(args)
    time.sleep(3)
    print('子进程id:', os.getpid())
    print('子进程的父进程id:', os.getppid())
    print('子进程执行结束..')

if __name__ == '__main__':

    p = Process(target=func,args=('星期一','星期二')) # 带参数函数注册进程
    p.start()
    print('主进程id：',os.getpid())
    print('主进程的代码执行完')

2. 多进程常用的几个方法：

      1> p.join()：设置主进程阻塞，等待子进程执行完毕后再继续执行主进程的代码，即主进程等待子进程执行完毕后，再执行自己后面的代码；

import os
import time
from multiprocessing import Process

def func(*args):
    print(args)
    time.sleep(3)
    print('子进程id:', os.getpid())
    print('子进程执行结束..')

if __name__ == '__main__':

    p = Process(target=func,args=('星期一','星期二')) # 带参数函数注册进程
    p.start()
    print('主进程id：',os.getpid())
    p.join()   # 主进程的代码执行到这里时，等待子进程执行并结束后，再执行主进程以下的代码，将程序在此处由异步 改为 同步
    print('等子进程执行完毕后，才会执行这里的代码。')
    print('主进程的代码执行完')

3. 开启几十个进程后，各子进程异步执行，在主进程的某个代码处需要等待所有子进程执行完毕后，再继续执行后面的代码，实现如下

import os
import time
from multiprocessing import Process

def func(arg1,arg2):
    print('子进程id:', os.getpid())
    print("*" * arg1)
    time.sleep(5)
    print("*" * arg2)

if __name__ == "__main__":
    p_list = []
    print('主进程id：', os.getpid())
    for i in range(1,5):
        p = Process(target=func, args=(2*i, 8*i))  # 带参数函数注册进程
        p_list.append(p)
        p.start()
        # p.join()  # 第一个子进程执行完毕后，再执行第二个子进程...直到最后一个子进程执行完毕后，再继续主进程后面的代码，即所有子进程和主进程都是同步的
    # p.join()  # 此时的p指的是for循环最后一个进程，所以这样只能达到最后一个进程与主进程在这之后由异步变成同步，而其他的子进程与主进程仍是异步
    [p.join() for p in p_list]  # 主进程要等待每一个异步执行的子进程执行完毕后，再继续执行后面代码，即每个异步子进程与主进程在这之后由异步变同步
    print('等子进程执行完毕后，才会执行这里的代码。')

4. 应用场景：同时写500个文件，待文件全部写完之后，展示所有的文件名

import os
from multiprocessing import Process

def func(filename,content):
    with open(filename,'w') as fs:
        fs.write(content*'=')

if __name__ == "__main__":
    p_list = []
    for i in range(1,5):
        p = Process(target=func,args=('info%s'%i, i))  # 多进程异步写4个文件，提升写文件的效率
        p_list.append(p)
        p.start()
    [i.join() for i in p_list]  # 等待所有文件写完成后，才能展示所有文件名
    # 向用户展示写入文件之后，文件夹中所有的文件名
    print([j for j in os.walk(r'D:old_boyDay36自己的')])

5. 另一种开启多进程的方法(面向对象) 

     1> 自定义一个类，继承Process类；

     2> 必须实现一个run()方法，即重写父类的run()方法，run方法的代码是在子进程中执行；

     3> 自定义的类若想传参数，初始化方法__init__记得一定要调用一下父类的__init__()，因为父类的初始化方法中还有很多其他属性是需要用到的；

import os
from multiprocessing import Process

class MyProcess(Process):
    def __init__(self,arg1,arg2):
        super().__init__()  # 若不调用父类的初始化方法，执行会报错 AttributeError
        self.arg1 = arg1
        self.arg2 = arg2

    def run(self):
        print(self.pid)  # 查看进程id，和os.getpid()同功效
        print(self.name)
        print(os.getpid())
        print(self.arg1)

    def func(self):
        print(self.arg2)

if __name__ == '__main__':
    print('主进程：',os.getppid())
    p1 = MyProcess(1,2)
    p1.start()  # start方法触发了调用run方法，而因为子类重写了run方法，即这里就是调用了MyProcess的run()

    p2 = MyProcess(3,4)
    p2.start()

6. 主进程和子进程的数据一般是完全隔离的，不共享的

import os
from multiprocessing import Process

def func():
    global n
    n = 0
    print('子进程id:%s'%os.getpid(),n)

if __name__ == "__main__":
    n = 200
    p = Process(target=func)
    p.start()
    p.join()
    print('主进程id: %s' %os.getpid(),n)
# 从执行结果可以得出：主进程和子进程的数据一般是完全隔离的，不共享的；

7. 使用多进程实现socket服务端的并发效果

import socket
from multiprocessing import  Process

# 一个socket服务端开启多个进程与多个客户端通信
def server(conn):
    ret = '你好。。'.encode('utf-8')
    conn.send(ret)
    msg = conn.recv(1024).decode('utf-8')
    print(msg)
    conn.close()

if __name__  == '__main__':
    sk = socket.socket()
    sk.bind(('127.0.0.1',8090))
    sk.listen()
    while True:
        conn,addr = sk.accept()
        p = Process(target=server,args=(conn,))
        p.start()

    sk.close()

import socket

sk = socket.socket()
sk.connect(('127.0.0.1',8090))

ret = sk.recv(1024).decode('utf-8')
print(ret)
msg = input('>>>>').encode('utf-8')
sk.send(msg)

sk.close()

PS：1> 每一个程序重新运行时都是一个新的进程，那么只要我们把客户端运行设置为：重新打开一个平行的窗口运行而不是关闭当前窗口重新运行，就可实现多个客户端的效果

         2>pycharm中的设置方法如下：pycharm工具栏---->run---->Edit Configurations---->Allow parallal run（在右上角的位置），勾上它即代表重新运行时是开一个新的窗口

        3> 启动server端后，启动一个客户端，就会开启一个子进程与服务端通信，启动多个客户端(一般多个客户的代码是相同的)后，多个客户端与server端即建立了通信；

8. 守护进程：主进程的代码执行结束，子进程的代码也应该执行结束，子进程应该随着主进程的结束而结束，这即为守护进程

      1> 一般默认情况下主进程是会等待子进程执行结束后，再结束主进程; 

      2> 而实际应用场景中，期望主进程的代码执行完成后，相关的子进程也结束；

      3> 没有进行设置时，子进程不会结束；

import time
from multiprocessing import Process

def func(): # 向主进程报告自己的状态
    while True:
        time.sleep(0.5)
        print('我还活着。')

if __name__ == "__main__":
    Process(target=func).start()
    i = 0
    while i < 2: 
        print('我是一个sokect server')
        time.sleep(5)
        i += 1

# 从执行结果可见，主进程的逻辑代码执行完后，子进程一直在执行，主进程也一直在等待子进程执行结束
# 而此时子进程不会自己结束 

     4> 设置子进程为守护进程：p.daemon = True，在p.start()前设置

import time
from multiprocessing import Process

def func(): # 向主进程报告自己的状态
    while True:
        time.sleep(0.5)
        print('我还活着。')

if __name__ == "__main__":
    p = Process(target=func)
    p.daemon = True  # 设置子进程为守护进程
    p.start()
    i = 0
    while i < 2:
        print('我是一个sokect server')
        time.sleep(5)
        i += 1

     5> 守护进程会随着主进程代码执行完毕而结束；

def func1(): # 向主进程报告自己的状态
    while True:
        time.sleep(0.5)
        print('我还活着。')

def func2():
    print('in func3 start..')
    time.sleep(9)
    print('in func3 finished..')

if __name__ == "__main__":
    p1 = Process(target=func1)
    p1.daemon = True  # 设置子进程为守护进程
    p1.start()
    p2 = Process(target=func2)
    p2.start()
    i = 0
    while i < 2:
        print('我是一个sokect server')
        time.sleep(2)
        i += 1
# 子进程1(守护进程)会随着主进程代码执行完毕而结束
# 主进程代码执行完成后,子进程1执行结束,但是主进程仍在等待子进程2执行结束,因为子进程2没有被守护

     6> 判断子进程是否活着：p.is_alive()，返回True表示活着，返回False表示死了；

     7> p.terminate()：结束进程，该方法执行后，进程不是立即就死了，而是有一个操作系统响应的过程；

     8> 获取进程名字：p.name

     9> 获取进程id：p.pid

def func1(): # 向主进程报告自己的状态
    while True:
        time.sleep(0.5)
        print('我还活着。')

def func2():
    print('in func3 start..')
    time.sleep(9)
    print('in func3 finished..')

if __name__ == "__main__":
    p1 = Process(target=func1)
    p1.daemon = True  # 设置子进程为守护进程
    p1.start()
    p2 = Process(target=func2)
    p2.start()
    p2.terminate()  # 结束一个子进程
    print(p2.is_alive())  # 结果为True,因为操作系统回收p2进程没有那么快
    time.sleep(1)
    print(p2.is_alive())  # 判断子进程是否活着
    print(p2.name)  # 当前进程的名字