03守护进程

"""
复习02进程join方面
"""
"""
需要模块
from multiprocessing import Process
from multiprocessing import Lock
import json
import time
"""
from multiprocessing import Process
from multiprocessing import Lock
import json
import time
def func(num):
    print("%s子进程" % (num))


if __name__ == '__main__':
    list = []  # 异步第一步定义一个空列表
    for i in range(10):
        p = Process(target=func,args=(i,))
        p.start()   # 对象开启是需要时间的
        # time.sleep(2)   # 可以先让他睡一会儿,少数进程的时候可行，但是多了不合适
        list.append(p)   # 异步第二步，把创建好的数据放到列表中
    for p in list:
        p.join()
    print("结束")    # 这个逻辑是快的，所以会先打印结束，收回去的话就打印一遍
    # 同步模型不适用,因为发邮件的话不可能只能按顺序发，当前一个发完后一个发

"""
用类开启进程
"""
class Pro(Process):
    def __init__(self, name):
        super().__init__()  # 要加上super方法才能不报错
        self.name = name


    def run(self):
        print(999)


if __name__ == '__main__':
    p = Pro("a")   # 进行实例化,传参的话加一个参数就好
    p.start()


"""
03 守护进程逻辑
报活系统

守护进程
p.daemon = True
例子：
监管人：看父亲，当父亲干完活，立马儿子停下带走结束。
僵尸进程：
守护进程守护到主进程结束的时候结束

文字数据来自学委：
一定要在开启子进程前设置,设置p为守护进程,
禁止p创建子进程,并且父进程代码执行结束,p即终止运行
"""

"""
并发效果，父进程已经结束了但是表面上还活着
"""
def func():
    while True:   # 如果程序正确，那么一直执行
        time.sleep(0.2)
        print("is_alive")   # 没有意义的，传数据是不可能实现的，

def func2():
    for i in range(1, 5):
        time.sleep(1)
        print("执行到第%s秒" % (i))   # 进行格式化


if __name__ == '__main__':
    p2 = Process(target=func2)
    p2.start()
    p = Process(target=func)
    p.daemon = True  # 守护进程   让它没有意义的情况不出现让它结束的
    p.start()   # 开启子进程
    time.sleep(3)
    p2.join()   # 整个过程都结束了，让他最后结束，保证子进程结束
    print("结束")

"""
不用守护进程   让他最后结束
"""
def func2():
    for i in range(1, 5):
        time.sleep(1)
        print("执行到第%s秒" % (i))   # 进行格式化


if __name__ == '__main__':
    p2 = Process(target=func2)
    p2.start()
    time.sleep(3)
    print("结束")
    # print(p2.is_alive())   # 监测是否还活着
    p2.terminate()   # 把进程杀死，在子进程结束之后就不会出来了
    time.sleep(0.1)   # 用时间延迟来反应系统
    print(p2.is_alive())   # 放在最后出现的还是True,是因为系统需要时间反应


"""
需要知识：操作文件   json 模块

锁  进程同步部分 安全机制，抢票，
多个程序执行同一段代码  异步

在一个时间段内，想要一个进程执行一段代码
"""

"""
以下是锁里面的方法，acquire获取钥匙   release还钥匙方法
"""
from multiprocessing import  Process
from multiprocessing import Lock   # 需要引入锁模块

lock = Lock()   # 实例化一个锁
lock.acquire()   # 获取钥匙
print(1)
lock.release()   # 还钥匙
lock.acquire()
print(2)
lock.acquire()
print(3)

"""
以下一张票卖给了多个人，不合理，数据不安全
"""
import json   # 需要引入json模块
# dic={"count":3}   a.txt文档中
def check(num):
    with open("a.txt", "r")as f:   # 使用with自动关闭，不用自己再去执行代码关闭
        obj = json.load(f)
        print("%s号查询，剩余票数是%s张" % (num, obj["count"]))


def buy(num):
    with open("a.txt", "r") as f:
        obj = json.load(f)  # 打开文件以下开始买票
        time.sleep(1)
        if obj["count"] > 0:
            obj["count"] -= 1
            time.sleep(1)
            with open("a.txt", "w") as f:
                json.dump(obj, f)
                print("%s号购票成功" % (num))


def check_buy(num):
    check(num)
    buy(num)


if __name__ == '__main__':
    for i in range(1, 11):
        p = Process(target=check_buy, args=(i,))
        p.start()


"""
换一种方式让一张票卖给一个人
"""
def check(num):
    time.sleep(0.1)
    with open("a.txt", "r")as f:   # 使用with自动关闭，不用自己再去执行代码关闭
        obj = json.load(f)
        print("%s号查询，剩余票数是%s张" % (num, obj["count"]))


def buy(num):
    with open("a.txt", "r") as f:
        obj = json.load(f)  # 打开文件以下开始买票
        time.sleep(0.3)
        if obj["count"] > 0:
            obj["count"] -= 1
            time.sleep(0.3)
            with open("a.txt", "w") as f:
                json.dump(obj, f)
                print("%s号购票成功,剩余票数是%s张" % (num, obj["count"]))
        else:
            print("没票了")


def check_buy(num, l):
    check(num)
    l.acquire()
    buy(num)
    l.release()


if __name__ == '__main__':
    lock = Lock()   # 实例化锁
    for i in range(1, 5):
        p = Process(target=check_buy, args=(i, lock))
        p.start()

"""
信号量
锁加计数器

比如大保健：提前设定好，一个房间只有4个床（计数器现在为4），
那么同时只能四个人进来，谁先来的谁先占一个床（acquire，计数器减1），
4个床满了之后（计数器为0了），第五个人就要等着，
等其中一个人出来（release，计数器加1），他就去占用那个床了。
"""
from multiprocessing import Process
from multiprocessing import Semaphore   # 需要引入信号量模块

sem = Semaphore(3)   # 计数器，放几把钥匙
sem.acquire()   # 获得钥匙
print(1)
sem.acquire()
print(2)
sem.acquire()
print(3)
sem.release()   # 释放钥匙
sem.acquire()
print(4)