day34

今日内容：

　　1、开启子进程的两种方式

　　2、join方法

　　3、进程之间内存空间相互隔离

　　4、僵尸进程和孤儿进程

　　5、守护进程

　　6、互斥锁

　　7、进程对象其他相关的属性和方法

1、开启子进程的两种方式

方式一：

from multiprocessing import Process

import time

# 开启子进程的方式一：借助于Process来开启子进程

def task(name):

    print(name,'子进程正在运行')

    time.sleep(3)

    print(name,'子进程death')

if __name__ == '__main__':

    p = Process(target=task,args=('yxf',))

    p.start()

    print('主进程')

方式二：

from multiprocessing import Process

import time

# 开启子进程的方式二：自己新建一个类通过继承Process这个类

class Myprocess(Process):

    def __init__(self,name):

        super().__init__()

        self.name = name

    def run(self):

        print(self.name,'正在运行')

        time.sleep(3)

        print(self.name,'death')

if __name__ == '__main__':

    p = Myprocess('yxf')

    p.start()

    print('主进程')

2、join方法

join方法的作用是：使得子进程结束之后再往下进行主进程

from multiprocessing import Process

import time

def tast(name):

    print(name,'子进程正在运行')

    time.sleep(3)

    print(name,'子进程death')

if __name__ == '__main__':

    p = Process(target=tast,args=('大张哥',))

    p.start()

    p.join()

    print('主进程')

　　

3、进程之间内存空间相互隔离

进程之间内存是达到了一种物理隔离的状态，所以进程之间的内存空间不能直接互相共享，并且如果可以共享也会导致数据混乱。

from multiprocessing import Process

n=100

def tast():

    global n

    n=0

    print(n)

if __name__ == '__main__':

    p = Process(target= tast)

    p.start()

    p.join()

    print(n)

    print('主进程')

4、僵尸进程和孤儿进程

僵尸进程对于计算机系统是有害的，因为僵尸进程没有人去管理，若不去清理会导致pid号被占用内存空间也会被占用，达到一定数量就会导致计算机开启不了程序了，所以我们需要手动回收掉这些进程

孤儿进程对于计算机系统是无害的，是因为再liunx系统下会有一个init去管理回收这些孤儿进程。

5、守护进程

守护进程是类似于绑定到主进程的，若主进程运行完毕，守护进程也会直接被关闭。若守护进程先运行完毕，那就守护进程相当于一个正常的子进程。

from multiprocessing import Process

import time

def tast(name):

    print(name,'老太监还活着')

    time.sleep(3)

    print(name,'老太监正常死亡')

if __name__ == '__main__':

    p = Process(target=tast,args=('张'))

    p.daemon = True

    p.start()

    time.sleep(2)

    print('主进程')

6、互斥锁

我们之前说子进程是无法在内存中共享自己的内存数据的，但是子进程可以共享计算机硬盘上的数据，因为在硬盘上数据并没有隔离，但是如果一份数据同时被多个子进程操作，那么就会导致数据的混乱，所以这时候就需要用到互斥锁，互斥锁的作用就是，将原本并发的子进程在互斥锁作用到的这段代码中变成串行方式去运行。

#我模拟的是一个抢票系统，我设定了json数据中只剩下了一张票，并产生了10个子进程去抢票

from multiprocessing import Process,Lock

import json

import time,random

def serch(name):

    print('客户%s,进入购票系统'%name)

    with open(r'E:\code\GoodDog\day34\a.json','rt',encoding='utf-8') as f:

        odd = json.load(f)

        time.sleep(1)

    print('客户%s,剩余票数：%s'%(name,odd['odd']))

def get(name):

    with open(r'E:\code\GoodDog\day34\a.json','rt',encoding='utf-8') as f:

        odd = json.load(f)

    if odd['odd']>0:

        time.sleep(random.randint(1,3))

        odd['odd']-=1

        with open(r'E:\code\GoodDog\day34\a.json', 'wt', encoding='utf-8') as f:

            json.dump(odd,f)

        print('客户%s,购票成功'%name)

    else:

        print('客户%s,购票失败'%name)

def tast(name,mutex):

    serch(name)

    mutex.acquire()

    get(name)

    mutex.release()

if __name__ == '__main__':

    mutex = Lock()

    for i in range(10):

        p = Process(target=tast,args=(i,mutex))

        p.start()

7、进程对象其他相关的属性和方法

from multiprocessing import Process,current_process

import time

def tast(name):

    print('%s%s子进程存活'%(name,current_process().pid))#current_process().pid：用来查看该进程的pid号

    time.sleep(3)

    print('%s%s子进程death'%(name,current_process().pid))

if __name__ == '__main__':

    p = Process(target=tast,args=('a',))

    p.start()

    p.terminate()#用来停止正在进行的这个子进程

    time.sleep(4)

    print(p.is_alive())#用来查看子进程是否还在运行

    p.join()

    print('主',current_process().pid)

调用OS模块查看PID号的方式：

from multiprocessing import Process

import os

import time

def tast(name):

    print('%s%s子进程存活'%(name,os.getppid()))#os.getppid():用来查看该子进程的主进程PID号

    time.sleep(3)

    print('%s%s子进程death'%(name,os.getpid()))#,os.getpid()：用来查看子进程的PID号

if __name__ == '__main__':

    p = Process(target=tast,args=('a',))

    p.start()

    # p.terminate()

    time.sleep(4)

    # print(p.is_alive())

    p.join()

    print('主',os.getppid())