并发编程-进程-06开启多进程

一丶multiprocess模块

multiprocess是python中一个操做、管理进程的包。

1.2建立多进程方法

multiprocess.process模块是一个建立进程的模块，借助这个模块，就能够完成进程的建立。

"""
建立进程就是在内存中从新开辟一块内存空间
将容许产生的代码丢进去
一个进程对应在内存就是一块独立的内存空间

进程与进程之间数据是隔离的 没法直接交互
可是能够经过某些技术实现间接交互
"""

1.2 建立方法

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

强调：

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

1.3参数介绍：

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

1.4方法介绍

• 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开启的进程

1.5 属性介绍

• p.daemon：默认值为False，若是设为True，表明p为后台运行的守护进程，当p的父进程终止时，p也随之终止，而且设定为True后，p不能建立本身的新进程，必须在p.start()以前设置

  ps: 这个能够在process建立对象时候后面加个参数 daemon=True也可!

• p.name：进程的名称

• p.pid：进程的pid

• p.exitcode：进程在运行时为None、若是为–N，表示被信号N结束(了解便可)

• p.authkey：进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络链接的底层进程间通讯提供安全性，这类链接只有在具备相同的身份验证键时才能成功（了解便可）

二丶注意事项

2.1windows中使用process的注意事项

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

三丶建立进程代码实现

3.1建立进程方式一

from multiprocessing import Process
import time


def test(name):
    print('%s is running'%name)
    time.sleep(3)
    print('%s is over'%name)

"""
windows建立进程会将代码以模块的方式 从上往下执行一遍
linux会直接将代码完完整整的拷贝一份


windows建立进程必定要在if __name__ == '__main__':代码块内建立  不然报错
"""
if __name__ == '__main__':
    p = Process(target=test,args=('egon',))  # 建立一个进程对象
    p.start()  # 告诉操做系统帮你建立一个进程
    print('主')

3.2建立进程方式二

# 建立进程的第二种方式
from multiprocessing import Process
import time

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

    def run(self):
        print('%s is running' % self.name)
        time.sleep(3)
        print('%s is over' % self.name)

if __name__ == '__main__':
    p = MyProcess('egon')
    p.start()
    print('主')

3.3join()方法使用案例

from multiprocessing import Process
import time

def test(name,i):
    print('%s is running'%name)
    time.sleep(i)
    print('%s is over'%name)
if __name__ == '__main__':
    p_list = []
    # for i in range(3):
    #     p = Process(target=test,args=('进程%s'%i,i))
    #     p.start()
    #     p_list.append(p)
    # for p in p_list:
    #     p.join()
    p = Process(target=test,args=('egon',1))
    p1 = Process(target=test,args=('kevin',2))
    p2 = Process(target=test,args=('jason',3))
    start_time = time.time()
    p.start()  # 仅仅是告诉操做系统帮你建立一个进程 至于这个进程何时创  操做系统随机决定
    p1.start()
    p2.start()
    p2.join()
    p.join()
    p1.join()

    # 主进程代码等待子进程运行结束 才继续运行
    # p.join()  # 主进程代码等待子进程运行结束
    print('主')
    print(time.time() - start_time)

四丶进程间数据隔离

from multiprocessing import Process
import time

money = 100

def test():
    global money
    money = 99999999

if __name__ == '__main__':
    p = Process(target=test)
    p.start()
    p.join()
    print(money)

五丶进程对象的部分方法

1. os.getpid()获取当前进程ID
2. os.getppid()获取父进程ID
3. current_process().pid获取当前进程ID ,推荐os的
4. 进程对象.is_alive()判断进程是否存活

from multiprocessing import Process,current_process
import os
import time


def test(name):
    # print('%s is running'%name,current_process().pid)
    print('%s is running'%name,'子进程%s'%os.getpid(),'父进程%s'%os.getppid())
    time.sleep(3)
    print('%s is over'%name)


if __name__ == '__main__':
    p = Process(target=test,args=('egon',))
    p.start()
    # p.terminate()  # 杀死当前进程  实际上是告诉操做系统帮你杀死一个进程
    time.sleep(1000)
    print(p.is_alive())  # 判断进程是否存活
    # print('主',current_process().pid)
    p.join()
    print('主',os.getpid(),'主主进程:%s'%os.getppid())

六丶守护进程

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

主进程建立守护进程

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

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

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

from multiprocessing import Process
import time


def test(name):
    print('%s总管正常活着'%name)
    time.sleep(3)
    print('%s总管正常死亡'%name)


if __name__ == '__main__':
    p = Process(target=test,args=('egon',))
    p.daemon = True  # 将该进程设置为守护进程   这一句话必须放在start语句以前 不然报错
    p.start()
    time.sleep(0.1)
    print('皇帝jason寿正终寝')

p.daemon：默认值为False，若是设为True，表明p为后台运行的守护进程，当p的父进程终止时，p也随之终止，而且设定为True后，p不能建立本身的新进程，必须在p.start()以前设置

七丶socket多进程实现聊天并发

7.1服务端

from socket import *
from multiprocessing import Process

server=socket(AF_INET,SOCK_STREAM)
server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
server.bind(('127.0.0.1',8080))
server.listen(5)

def talk(conn,client_addr):
    while True:
        try:
            msg=conn.recv(1024)
            if not msg:break
            conn.send(msg.upper())
        except Exception:
            break

if __name__ == '__main__': # windows下start进程必定要写到这下面
    while True:
        conn,client_addr=server.accept()
        p=Process(target=talk,args=(conn,client_addr))
        p.start()

7.2客户端

from socket import *

client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8080))


while True:
    msg=input('>>: ').strip()
    if not msg:continue

    client.send(msg.encode('utf-8'))
    msg=client.recv(1024)
    print(msg.decode('utf-8'))

八丶僵尸进程和孤儿进程

1. 父进程回收子进程资源的两种方式
   1.join方法
   2.父进程正常死亡
   全部的进程都会步入僵尸进程

2. 孤儿进程(无害的)
   子进程没死 父进程意外死亡

   针对linux会有儿童福利院(init) 若是父进程意外死亡他所建立的子进程都会被福利院收养

ps:孤儿进程是无害的由于"有人"收留,可是僵尸进程确实有害的,它的存在会占用pid,会致使最后无pid可用,会最终影响整个电脑的运行