并发编程【三】进程

使用multiprocessing模块操作进程

 1、Process模块介绍

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

Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）

强调：
1. 需要使用关键字的方式来指定参数
2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号

参数介绍：
1 group参数未使用，值始终为None
2 target表示调用对象，即子进程要执行的任务
3 args表示调用对象的位置参数元组，args=(1,2,'egon',)
4 kwargs表示调用对象的字典,kwargs={'name':'egon','age':18}
5 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 的时候  ，就不会递归运行了。

2、使用Process模块创建进程

在python中开启一个子进程

import os
import time
from multiprocessing import Process
def func():
    time.sleep(2)
    print(os.getpid(),os.getppid())
if __name__ == "__main__":
    Process(target=func).start()

多个进程同时运行（注意，子进程的执行顺序不是根据启动顺序决定的）

import time
import random
from multiprocessing import Process
def send_mail(name):
    time.sleep(random.uniform(1,3))
    print('已经给%s发送邮件完毕'%name)
if __name__ == '__main__':
    lst = ['alex','egon','eva_j']
    lis_l = []
    for name in lst:
        p = Process(target=send_mail,args=(name,))
        p.daemon = True
        p.start()
        lis_l.append(p)
    for p in lis_l:p.join() # 异步阻塞
    print('所有的信息都已经发送完毕')

多个进程同时运行

面向对象的方式实现多进程

import os
from multiprocessing import Process

class Myprocess(Process):
    def f(self):
        print(11)

    def __init__(self,a,b):
        super().__init__()
        self.a = a
        self.b = b
        # print(a,b)
    def run(self):
        self.f()
if __name__ == '__main__':
    Myprocess(1,2).start()

面向对象的方式实现多进程

进程与进程之间的数据隔离

关于if __name__ == '__main__'：

"""
导入模块的时候实际上是运行了一遍这个模块里面的内容;
写的所有代码是不希望这个文件作为模块被导入的时候执行;
我们就加上if __name__ == '__main'__
"""
在当前文件执行__name__ == 'main'
当该文件作为模块被导入的时候 __name__ == '模块名'

3、守护进程

守护进程会随着主进程的代码结束而结束；

主进程创建守护进程

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

　　其二：守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children

注意：进程之间是互相独立的，主进程代码运行结束，守护进程随即终止

import os
import time
from multiprocessing import Process

class Myprocess(Process):
    def __init__(self,person):
        super().__init__()
        self.person = person
    def run(self):
        print(os.getpid(),self.name)
        print('%s正在和女主播聊天' %self.person)


p=Myprocess('哪吒')
p.daemon=True #一定要在p.start()前设置,设置p为守护进程,禁止p创建子进程,并且父进程代码执行结束,p即终止运行
p.start()
time.sleep(10) # 在sleep时查看进程id对应的进程ps -ef|grep id
print('主')

from multiprocessing import Process

def foo():
    print(123)
    time.sleep(1)
    print("end123")

def bar():
    print(456)
    time.sleep(3)
    print("end456")


p1=Process(target=foo)
p2=Process(target=bar)

p1.daemon=True
p1.start()
p2.start()
time.sleep(0.1)
print("main-------")#打印该行则主进程代码结束,则守护进程p1应该被终止.#可能会有p1任务执行的打印信息123,因为主进程打印main----时,p1也执行了,但是随即被终止.

主进程代码执行结束守护进程立即结束

4、socket server端并发实列

一定要注意循环导入问题：

 

错误示例：

import socket
from multiprocessing import Process
def run(conn):
    while True:
        msg = conn.recv(1024).decode('utf-8')
        print(msg)
if __name__ == '__main__':
    sk = socket.socket()
    sk.bind(('127.0.0.1', 9000))
    sk.listen()
    while 1:
        conn, addr = sk.accept()
        Process(target=run, args=(conn,)).start()

函数式编程实现并发

import socket
from multiprocessing import Process
class Myprocess(Process):
    def __init__(self,conn):
        super().__init__()
        self.conn = conn
    def run(self):
        while True:
            msg = self.conn.recv(1024).decode('utf-8')
            print(msg)
if __name__ == '__main__':
    sk = socket.socket()
    sk.bind(('127.0.0.1',9000))
    sk.listen()
    while True:
        conn,addr = sk.accept()
        Myprocess(conn).start()

面向对象实现并发

5、多进程的数据共享问题

from multiprocessing import Process
def func(dic):
    dic['count'] -= 1
if __name__ == '__main__':
    dic = {'count':100}
    lis = []
    for i in range(100):
        p = Process(target=func,args=(dic,))
        p.start()
        lis.append(p)
    for j in lis:
        j.join()
    print(dic)     # 进程之间的数据是隔离的{'count': 100}修改不生效

多进程数据隔离

om multiprocessing import Manager
def func(dic):
    dic['count'] -= 1
if __name__ == '__main__':
    m = Manager()             # 管理员
    dic = m.dict({'count': 100})
    lis = []
    for i in range(100):
        p = Process(target=func,args=(dic,))
        p.start()
        lis.append(p)
    for j in lis:
        j.join()
    print(dic)     # 进程之间的数据是隔离的{'count': 5}修改不生效

# 100减100次1这么慢? 不是减操作造成的 而是开启进程 管理进程 销毁进程拖慢了程序的执行速度
# 为什么在这里出现了数据不安全的现象?
# 什么情况下会出现数据不安全 : Manager类当中对字典\列表  += -= *= /=
# 如何解决 : 加锁

多进程数据共享