Python全栈学习笔记day 36：multiprocessing.process模块、多进程中方法、多个子进程、开启多进程的第二种方式、守护进程、锁

import os
import time
from multiprocessing import Process
def func(args,args2):       #子进程要做的事
    print(args,args2)
    time.sleep(3)
    print('子进程 :', os.getpid())
    print('子进程的父进程 :', os.getppid())


if __name__ == '__main__':
    p = Process(target=func,args=('参数','参数2'))   # 注册
    # p是一个进程对象,还没有启动进程
    p.start()       # 开启了一个子进程
    print('*'*10)
    print('父进程 :',os.getpid()) # 查看当前进程的进程号
    print('父进程的父进程 :',os.getppid()) # 查看当前进程的父进程

二、多进程中方法join（）

p.join()     # 是感知一个子进程的结束,将异步的程序改为同步

import time
from multiprocessing import Process

def func(arg1,arg2):
    print('*'*arg1)
    time.sleep(5)
    print('*'*arg2)

if __name__ == '__main__':
    p = Process(target=func,args=(10,20))
    p.start()
    print('hahahaha')
    p.join()     # 是感知一个子进程的结束,将异步的程序改为同步
    print('====== : 运行完了')

三、多个子进程

栗子：多进程写文件：首先往文件夹中写文件，写入文件之后，向用户展示文件夹中所有的文件名

import os
from multiprocessing import Process

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

if __name__ == '__main__':
    p_lst = []
    for i in range(10):
        p = Process(target=func,args=('info%s'%i,0))
        p_lst.append(p)
        p.start()
    for p in p_lst:p.join()   # 之前的所有进程必须在这里都执行完才能执行下面的代码
    print([i for i in os.walk(r'文件存放位置')])

四、开启多进程的第二种方式（面相对象的方式）

自定义类 继承Process类
必须实现一个run方法,run方法中是在子进程中执行的代码

格式：

from multiprocessing import Process

class MyProcess(Process):
    def __init__(self,arg1,arg2):
        super().__init__()
        self.arg1 = arg1
        self.arg2 = arg2

    def run(self):
        print(self.pid)
        print(self.name)
        print(self.arg1)
        print(self.arg2)

if __name__ == '__main__':
    p1 = MyProcess(1,2)
    p1.start()
    p2 = MyProcess(3,4)
    p2.start()

多进程之间数据是隔离的，使用了全局变量global也是隔离的

六、守护进程

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

在主进程内结束一个子进程 p.terminate()

结束一个进程不是在执行方法之后立即生效,需要一个操作系统响应的过程

检验一个进程是否活着的状态 p.is_alive()

p.name p.pid 这个进程的名字和进程号

import time
from multiprocessing import Process

def func():    守护程序
    while True:
        time.sleep(0.2)
        print('我还活着')

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

if __name__ == '__main__':
    p = Process(target=func)
    p.daemon = True   # 设置子进程为守护进程
    p.start()
    p2 = Process(target=func2)
    p2.start()
    p2.terminate()     # 结束一个子进程
    time.sleep(1)
    print(p2.is_alive())  # 检验一个进程是否还活着
    print(p2.name)

七、锁lock

栗子：买火车票，只有一张票十个人来买。ticket文件中：{"ticket": 1}

import json
import time
from multiprocessing import Process
from multiprocessing import Lock


def show(i):    展示火车票
    with open('ticket') as f:
        dic = json.load(f)
        print('余票：%s'%dic['ticket'])

def buy_ticket(i, lock):                买票
    lock.acquire()              # 拿钥匙进门
    with open('ticket') as f:
        dic = json.load(f)
        time.sleep(0.1)
    if dic['ticket'] > 0 :
        dic['ticket'] -= 1
        print('%s买到票了'%i)
    else:
        print('%s没买到票'%i)
    time.sleep(0.1)
    with open('ticket', 'w') as f:
        json.dump(dic, f)
    lock.release()          # 还钥匙

if __name__ == '__main__':
    lock = Lock()
    for i in range(10):                10个人买票
        p = Process(target=buy_ticket, args=(i,lock))
        p.start()