守护进程 互斥锁 进程间通讯

1. 守护进程：
    from multiprocessing import Process
    import time
    def task():
        print("11111111111111")
        time.sleep(3)
        print("222222222222")

    if __name__ == '__main__':
        p=Process(target=task)
        p.daemon=True#p是主进程的守护进程
        p.start()
        print("3333333333")
        print("4444444444")
    #守护进程在被守护进程死亡时会随之死亡
    #注意：p.daemon=True必须在启动进程前执行

2.互斥锁*****

    当多个进程 同时读写同一份数据 数据很可能就被搞坏了。并发式读写会导致文件最后无法解码.（并发无法控制进程顺序）
    目前可以使用join来将所有程序并发改成串行
    多个进程并发的访问了同一个资源 将导致资源竞争（同时读取不会产生问题 同时修改才会出现问题）

    第一个方案 加上join 但是这样就导致了不公平  相当于火车进站无论什么时间开的都必须按照队伍来，不能紧急通行
    第二个方案 加锁 谁先抢到资源谁先处理

    相同点：都编程了串行
    不同点：join顺序是固定的 加锁的顺序不是固定的
    注意：要想锁住资源必须保证大家拿到的是同一把锁

    怎么使用？
        在需要加锁的地方 lock.acquire（）表示锁定 ，在代码执行完后 一定要lock.release（）

    加锁举例：
    from multiprocessing import Process,Lock
    import time
    #买了把锁
    mutex = Lock()
    def task1(Lock):
        Lock.acquire()
        time.sleep(3)
        print("===>")
        Lock.release()
    def task2(Lock):
        Lock.acquire()
        print("=======>")
        Lock.release()
    def task3(Lock):
        Lock.acquire()
        print("===============>")
        Lock.release()
    if __name__ == '__main__':
        p1 = Process(target=task1,args=(mutex,))
        p2 = Process(target=task2,args=(mutex,))
        p3 = Process(target=task3,args=(mutex,))
        p1.start()
        p3.start()
        p2.start()
        print("over")
    #加锁后开启进程顺序就变成了 执行进程顺序（串性）



    例子：抢票
        from multiprocessing import Process,Lock
        import json
        import time,random
        #买了把锁
        def task1(name):
            time.sleep(random.randint(1,3))
            with open("D:\py_yingyong\新课上练习\ppppp.json","rt",encoding="utf-8")as f:
                dic=json.load(f)
                print("%s进行了查票  余票%s张"%(name,dic["count"]))
                return dic
        def task2(name):
            time.sleep(random.randint(1,3))
            with open("D:\py_yingyong\新课上练习\ppppp.json","rt",encoding="utf-8")as f:
                dic=json.load(f)
                print("%s进行了购票操作  现余票%s张"%(name,dic["count"]))
            if dic["count"]>0:
                dic["count"]=dic["count"] - 1
                with open("D:\py_yingyong\新课上练习\ppppp.json", "wt", encoding="utf-8")as f:
                    json.dump(dic,f)
                    print("%s购票成功"%name)
            return
        def task3(Lock,name):
            task1(name)
            Lock.acquire()
            task2(name)
            Lock.release()
        if __name__ == '__main__':
            mutex = Lock()
            for i in range(5):
                p1 = Process(target=task3,args=(mutex,"客户%s"%i))
                p1.start()

3.IPC
    指的是进程间的通讯
    之所以开启子进程 肯定是需要他来帮我们完成任务 很多情况下，需要将数据返回给父进程
    然而 进程内存是物理隔离的
    解决方案：
    1.将共享数据放到文件中
    2.管道 subprocess中的那个 管道只能单项通讯 必须存在父子关系
    3.共享一个内存区域 需要操作系统帮你分配 速度快:
        Manager 共享列表或字典
            from multiprocessing import Process, Manager
            import time
            def task(li,i):
                print("子进程xxxx")
                li[0]=1+i
                print(li[0])
                # dic["name"]="xx"
            if __name__ == '__main__':
                # with Manager() as m:
                m=Manager()
                li=m.list([2])
                #     dic=m.dict({})
                # li=[1]
                #开启子进程
                for i in range(3):
                    p=Process(target=task,args=(li,i))
                    p.start()
                    p.join(1)
                print(li)


        Queue 是一个队列 带有阻塞效果:
            from multiprocessing import Process,Queue
            #创建队列
            q=Queue()#阻塞
            q.put("len")
            q.put(124)
            q.put("kkkk")
            print(q.get())
            #如果取空会等待
            print(q.get())


            q=Queue(3)#阻塞
            q.put("len",block=False)
            #当容量满的时候在执行put会默认阻塞知道执行了get为止
            #如果修改block=False 直接报错 因为没有地方放了
            q.put(124,block=False)
            q.put("kkkk",block=False)
            #去除数据 如果没有数据默认是阻塞的  直到执行了put
            #如果取空会等待
            print(q.get(),block=False)
            #如果修改block=False 直接报错 因为没有数据可以取了
            print(q.get(),block=False)
            print(q.get())
            print(q.get())

            q=Queue()
            #如果满了 愿意等待3秒 如果还等不到位置 就会报错
            q.put("len",timeout=3)
            q.put(124,timeout=3)
            q.put("kkkk",timeout=3)


            print(q.get(),timeout=3)
            #如果数据空了 愿意等待3秒 如果还没有数据 就会报错
            print(q.get(),timeout=3)
            print(q.get(),timeout=3)
            print(q.get(),timeout=3)