创建进程基础

目录

• 创建进程基础
  • multiprocessing模块
  • multiprocessing.Process模块
  • Process模块介绍
    • 主要方法介绍
    • 主要属性介绍
    • 创建进程注意事项
  • 使用process模块创建进程
  • 通过继承Process类开启进程
  • 进程之间的数据隔离问题
  • 守护进程
  • 模拟网络购票

创建进程基础

multiprocessing模块

​ 仔细说来，multiprocess不是一个模块而是python中一个操作、管理进程的包。 之所以叫multi是取自multiple的多功能的意思,在这个包中几乎包含了和进程有关的所有子模块。由于提供的子模块非常多，为了方便大家归类记忆，我将这部分大致分为四个部分：创建进程部分，进程同步部分，进程池部分，进程之间数据共享。

multiprocessing.Process模块

process模块是一个创建进程的模块，借助这个模块就能完成进程的创建。

Process模块介绍

Process([group [, target [, name [, args [, kwargs]]]]])

由该类类实例化得到的对象，表示一个子进程中的任务

强调：

• 需要使用关键字的方式来指定参数
• args指定的为传给targe函数的位置参数，是一个元组形式，而且必须有逗号

参数介绍：

• group参数未使用，值始终为None
• target表示调用对象，即子进程要执行的任务
• args表示调用对象的位置参数元组，args=(1,2,'egon',)
• kwargs表示调用对象的字典，kwargs={'name':'egon','age':18}
• name为子进程的名称

主要方法介绍

• p.start()：启动进程，并且调用该子进程中的p.run()
• p.run()：进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法
• p.terminate()：强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁
• p.is_alive()：如果p仍然运行，返回True
• p.join([timeout])：主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是,p.join()只能join住start开启的进程，而不能join住run开启的进程

主要属性介绍

• p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置
• p.name：进程的名称
• p.pid：进程的pid
• p.exitcode：进程在运行时为None、如果为–N，表示被信号N结束(了解即可)
• p.authkey：进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）

创建进程注意事项

​ 在Windows操作系统中由于没有fork(linux操作系统中创建进程的机制)，在创建子进程的时候会自动 import 启动它的这个文件，而在 import 的时候又执行了整个文件。因此如果将process()直接写在文件中就会无限递归创建子进程报错。所以必须把创建子进程的部分使用if __name__ =='__main__' 判断保护起来，import 的时候，就不会递归运行了。

使用process模块创建进程

在一个python进程中开启子进程

from multiprocessing import Process

def foo(name):
    print('hello',name)

if __name == '__main__':
    p = Process(target = foo,args = ('wzh',))
    p2 = Process(target = foo,args = ('wang',))
    p.start() # p线程开启
    p2.start()
    print('父进程……')  # 先执行父进程的代码再执行子进程
'''
父进程……
hello wzh
hello wang
'''

方法使用：

from multiprocessing import Process,current_process
import time
import os
def foo(i):
    print(f'进程{i}开始。。。')
    time.sleep(1)
    print('子：',os.getpid())
    print(current_process().pid)
    print('父：', os.getppid())
    print(f'进程{i}结束。。。')

if __name__ == '__main__':
    for i in range(3):
        p = Process(target=foo,args= (i,))
        p.start()
        p.join()  # 等待子进程执行完成之后再执行父进程
        print(p.name)
        print(p.is_alive())
        print(p.terminate())

        print('子：',p.pid)
        print('父：',os.getpid())
        print('主进程开始。')
'''
进程0开始。。。
子： 1408
1408
父： 12168
进程0结束。。。
Process-1
False
None
子： 1408
父： 12168
主进程开始。
'''

多个进程同时运行中join()的使用

import time
from multiprocessing import Process


def f(name):
    print('hello', name)
    time.sleep(1)


if __name__ == '__main__':
    for i in range(3):
        p = Process(target=f, args=('wzh',))
        p.start()
        p.join()
    print('父进程在执行')
'''
hello wzh
hello wzh
hello wzh
父进程在执行
'''

通过继承Process类开启进程

import os
from multiprocessing import Process

class Foo(Process):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        print(os.getpid())

if __name__ == '__main__':
    p1 = Foo('wzh')
    p2 = Foo('wang')
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    print('主进程。')
'''
11108
5928
主进程。
'''

进程之间的数据隔离问题

from multiprocessing import Process
# 主进程与子进程之间的数据互不干扰，相互独立
def work():
    global n
    n = 0
    print('子进程：',n)
if __name__ == '__main__':
    n = 100
    p = Process(target = work)
    p.start()
    print('主进程：',n)
'''
主进程： 100
子进程： 0
'''

守护进程

守护进程会随着主进程的结束而结束。

主进程创建守护进程

　　其一：守护进程会在主进程代码执行结束后就终止

　　其二：守护进程内无法再开启子进程,否则抛出异常：

import os
import time
from multiprocessing import Process

class Foo(Process):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        print(os.getpid(), self.name)
        time.sleep(1.9)
        print('当你打印了这句话时，说明我还没有死！')

if __name__ == '__main__':
    p = Foo('wzh')
    p.daemon = True # 将p这个子进程变为守护进程，当主进程执行结束时，p也会结束
    p.start()
    time.sleep(2)
    print('主进程')
'''
5928 wzh
当你打印了这句话时，说明我还没有死！
主进程
'''

模拟网络购票

from multiprocessing import Process
import json
import time
def read():
    with open('ticket','rt') as f:
        dic = json.load(f)
        return dic

def save(data):
    with open('ticket','wt') as f:
        json.dump(data,f)

def get(name):
    time.sleep(0.5)
    dic = read()
    if dic['count'] == 0:
        return False,f'{name}余票不足，购买失败!'
    if dic['count'] >= 1:
        dic['count'] -= 1
        save(dic)
        return True,f'{name}购票成功！剩余车票{dic["count"]}'

def buy(name):
    flag,msg = get(name)
    if flag:
        print(msg)
    else:
        print(msg)

if __name__ == '__main__':
    for i in range(5):
        p = Process(target=buy,args=(f'进程{i}:',))
        p.start()
        p.join()
'''
进程0:购票成功！剩余车票2
进程1:购票成功！剩余车票1
进程2:购票成功！剩余车票0
进程3:余票不足，购买失败!
进程4:余票不足，购买失败!
'''