进程之间的交互

守护进程：
    1，什么是守护进程？
        守护进程就是在父进程代码运行完毕后就结束的进程，本身就是一个进程
    2，守护进程的使用场景，
        在父进程的代码运行完毕之后就没有存在的意义了，就需要释放该进程
    3，使用守护进程，
        from multiprocessing import Process
        def runing(参数1，参数2，.....)：
            代码1，
            代码2，
            代码3
        if __name__ == '__main__':
            p1 = Process(target=runing,args=(参数1，参数2，参数3，...))
            p1.daemon = True
            p1.start()


        实际上守护进程的使用方式和进程一样，只是将对象的daemon属性改为了True，守护进程本身就是一个进程，只是会自动的在父进程结束后就自动释放


2，互斥锁：
    1，什么是互斥锁，
        互斥锁就是将一个并发的进程变为一个类似串行的进程，但是和串行还不同，串行的进程执行顺序是固定的一个一个的，但是被加锁的进程每一次都之只同时执行一个
    2，互斥锁使用场景，当程序当中锁执行的线程不能是并发执行时需要将该进程加锁，
    3，互斥锁的使用方法
        from multiprocessing import Process,Lock
        def pro(value1,value2,value3....):
            code1,
            code2,
            code3,
            ......
            locked.acquire()
            run2()
            locked.release()
        def run2():
            pass
        if __name__ == '__main__':
            pro = Process(pro,(value1,value2,value3......))
            locked = Lock()



            pro.start()



        对多个进程加锁时需要把多个进程都放入acquire,与release中，
        acquire语句都必须发放在release之后

3，进程与进程之间的通信，
    1，什么时进程之间的通信
        进程具有空间上的独立性，怎么才能在空间上让进程之间的数据同步？
    2，怎么才能让进程之间进行通信，
        使用管道与队列，管道PIPE,队列Queue
        3,管道，PIPE
            管道只能让两个进程之间实现通信交换数据，
            具体使用略
        4，队列
            一个队列，先进后出
            使用get，put来对队列加值
                get参数：
                block：当列队为empty时，会等待向队中添加值，并不会抛出异常，等待时间为timeout的时间
                timeout:设置列队为空的时候等待的时间，或为满的时候的等待时间

            joinableQueue  新添加了两个方法，join（），task_done()
                join(),如果队列的状态为empty，则关闭队列
                task_done(),记录取值记录


    3，进程与进程之间的信息交互的具体实现（生产者，消费者体系）
        from multiprocessing import Process,joinableQueue
        def run1(参数1，参数2，参数3，.....,队列的一个对象que):
            代码1
            代码2
            代码3，。。。。
            que.put(值，block=True，timeout=5)
        def run2(参数1，参数2，参数3，。。。。。。队列的)
            代码1
            代码2
            代码3，。。。。
            que.get(block=True，timeout=5)


        if __name__ == '__main__':
            que = Queue()   #可以在声明队列的对象的时候不为对象指定队列容器的大小
            pro1 = Process(target=run1,args=(参数1，参数2，参数3....队列对象))
            pro2 = Process(target=run1,args=(参数1，参数2，参数3....队列对象))
            pro3 = Process(target=run3,args=(参数1，参数2，参数3....队列对象))
            pro3.daemon = True
            pro1.start()
            pro2.start()
            pro3.start()
            pro1.join()
            pro2.join()
            que.join()