Day34

今日内容：

　　1、开启进程的两种方法；

　　2、join方法；

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

　　4、进程对象其他相关的属性或方法；

　　5、僵尸进程与孤儿进程；

　　6、守护进程；

　　7、互斥锁

一、开启进程的两种方式：

开启子进程的方式一：

from multiprocessing import Process
import time

def task(name):
    print('%s is running' %name)
    time.sleep(3)
    print('%s is done' %name)

# 在windows系统上,开启子进程的操作必须放到if __name__ == '__main__'的子代码中
if __name__ == '__main__':
    p=Process(target=task,args=('egon',)) #Process(target=task,kwargs={'name':'egon'})
    p.start() # 只是向操作系统发送了一个开启子进程的信号
    print('主进程')

开启子进程的方式二：

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 done' % self.name)


# 在windows系统上,开启子进程的操作必须放到if __name__ == '__main__'的子代码中
if __name__ == '__main__':
    p = Myprocess('egon')
    p.start()  # 只是向操作系统发送了一个开启子进程的信号
    print('主进程')

二、join方法：

主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。需要强调的是，p.join只能join住start开启的进程

简单来说，就是join让主进程在原地等待，等待子进程运行完毕，不会影响子进程的执行

from multiprocessing import Process
import time


def task(name,n):
    print('%s is running'%name)
    time.sleep(n)
    print('%s is done'%name)


if __name__ == '__main__':
    p1=Process(target=task,args=('p1',1))
    p2 = Process(target=task, args=('p2', 2))

    p1.start()
    p2.start()

    p1.join()
    p2.join()
    print('主程序')

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

虽然进程之间是空间上的复用，但是在内存中其实每个进程之间都是在物理层面上隔开的，接下来就用代码来验证

from multiprocessing import Process


n=100
def task():
    global n
    n=0
    print('子进程n=',n)#0


if __name__ == '__main__':
    p1=Process(target=task)
    p1.start()
    p1.join()
    print('主进程n=',n)#100

主进程与子进程之间互不干扰，子进程是对主进程的拷贝。

四、进程对象其他的相关属性

1. pid：进程的唯一ID号
    1. current_process().pid: 当前进程的ID号
    2. os.getpid: 当前进程的ID号
    3. os.getppid: 当前进程的父进程ID号
2. name: 当前进程的name
3. p.terminate(): 强制终止进程p
4. p.is_alive(): 如果p仍然运行，返回True

from multiprocessing import Process,current_process
import time,os
def task():
    print('%s is runing father is %s'%(os.getpid(),os.getppid()))

    print('%s is done'%os.getpid())

if __name__ == '__main__':
    p = Process(target=task,name='子进程')
    print(p.name)
    p.start()
    p.terminate()#关闭进程,不会立即关闭,所以is_alive立刻查看的结果可能还是存活
    print(p.is_alive())#判断进程是否关闭,返回是True
    time.sleep(0.1)
    print(p.is_alive())#返回是False
    print('主进程',os.getpid(),os.getppid())

进程对象的terminate,is_alive方法和name属性

五、僵尸进程与孤儿进程

　　基本概念:

　　在unix/linux中,正常情况下,子进程都是通过父进程创建的,子进程再创建新的进程,子进程的结束和父进程的运行是一个异步过程,即父进程永远无法预测子进程到底什么时候结束.当一个进程完成它的工作之后,它的父进程需要调用wait()或者waitpid()系统调用取得子进程的终止状态.

　　孤儿进程:一个父进程退出,而它的一个或多个子进程还在运行,那么那些子进程将成为孤儿进程,孤儿进程将被init进程所收养,并由init进程对它们完成状态收集工作

　　僵尸进程:一个进程使用fork创建子进程,如果子进程退出,而父进程并没有调用wait()或waitpid()获取子进程的状态信息,那么子进程的进程描述符仍然保存在系统中.

六、守护进程

本质就是一个"子进程",该"子进程"的生命周期<=被守护进程的生命周期

from multiprocessing import Process
import time


def task(name):
    print('%s is 活着'%name)
    time.sleep(3)
    print('%s is 死了'%name)


if __name__ == '__main__':
    p=Process(target=task,args=('egon',))
    p.daemon=True
    p.start()
    time.sleep(1)
    print('主正在死')

七、互斥锁

每个线程互相独立，相互之间没有任何关系，但是在同一个进程中的资源，线程是共享的，如果不进行资源的合理分配，对数据造成破坏，使得线程运行的结果不可预期。这种现象称为“线程不安全”。

某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。

import json
import time,random
from multiprocessing import Process,Lock

def search(name):
    with open('db.json','rt',encoding='utf-8') as f:
        dic=json.load(f)
    time.sleep(1)
    print('%s 查看到余票为 %s' %(name,dic['count']))

def get(name):
    with open('db.json','rt',encoding='utf-8') as f:
        dic=json.load(f)
    if dic['count'] > 0:
        dic['count'] -= 1
        time.sleep(random.randint(1,3))
        with open('db.json','wt',encoding='utf-8') as f:
            json.dump(dic,f)
            print('%s 购票成功' %name)
    else:
        print('%s 查看到没有票了' %name)

def task(name,mutex):
    search(name) #并发
    mutex.acquire()
    get(name) #串行
    mutex.release()

    # with mutex:
    #     get(name)

if __name__ == '__main__':
    mutex = Lock()
    for i in range(10):
        p=Process(target=task,args=('路人%s' %i,mutex))
        p.start()
        # p.join() # join只能将进程的任务整体变成串行