进程之间的交互

守护进程:
    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,队列
            一个队列,先进后出
            使用getput来对队列加值
                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=Truetimeout=5)
        def run2(参数1,参数2,参数3,。。。。。。队列的)
            代码1
            代码2
            代码3,。。。。
            que.get(block=Truetimeout=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()





阅读更多
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭