进程总结

素颜马尾好姑娘i 2021-10-30 07:32 278阅读 0赞

**进程**  
函数当进程：  
python 中创建多进程的方式有俩种：  
函数当作进程  
类当作进程

"""函数当进程"""
    import os 
    import time
    import random
    from multiprocessing import Process
    
    def task(name):
        s = random.randint(1,10)
        print('pid: %s, name: %s, sleep %s ...'%(os.getpid(),name,s))
        time.sleep(s)
    
    if __name__ == "__main__":
        #创建6个子线程执行
        ps = []
        for i in range(5):
            p = Process(target =task,args = ('p%s' %i,))
            ps.append(p)
            p.start()
    
    
        #主线程等待子线程结束
        for p in ps:
            p.join() #这句话保证子进程结束后在往下执行
    
    使用 p = Process(target=func, arges=(arg1,arg2...))即可创建一个进程，调用p.start()启动一个进程，p.join()使得主进程等待子进程执行结束后才退出。

***QUEUE***  
如果多个进程之间要通信，可以使用队列，Python提供了Queue模块，

import time
    import random
    from multiprocessing import Process,Queue
    
    class P1(Process):
        
        def __init__(self,queue):
            self.queue = queue
            super(P1,self).__init__()
    
        def run(self):
            #此进程负责put数据
            for i in range(5):
                time.sleep(random.randint(1,3))
                self.queue.put(i)
                print('put: P1-->%s'%i)
    
    class P2(Process):
        def __init__(self, queue):
            self.queue = queue
            super(P2, self).__init__()
        def run(self):
            # 此进程负责read数据
            print ('P2 read ...')
            while 1:
                i = self.queue.get()
                print ('get: P2 -> %s' % i)
    
    if __name__ == '__main__':
        # 创建多进程队列 使之可通信
        queue = Queue()
        # 创建进程
        p1 = P1(queue)
        p2 = P2(queue)
        # 启动进程
        p1.start()
        p2.start()
        # 主进程等待P1子进程执行
        p1.join()
        # P2执行的是死循环 只能强制结束
        p2.terminate()
    
    一共2个进程，一个进程使用queue.put()负责向队列写入数据，另一个使用queue.get()队列中读取数据，实现了2个进程之间的信息通信

***Pipe***  
Python多进程模块中提供了Pipe，意为管道的意思，两端都可以进行读写操作

import time
    import random
    from multiprocessing import Process, Pipe
    
    class P1(Process):
    
        def __init__(self,pipe):
            self.pipe = pipe
            super(P1,self).__init__()
    
        def run(self):
            #发送
            print('P1 send...')
            for i in range(3):
                time.sleep(random.randint(1,2))
                self.pipe.send(i)
                print('send: P1->%s'%i)
    
            #接收
            print('P1 recv ...')
            for i in range(3):
                i = self.pipe.recv()
                print('recv: P1->%s'%i)
    
    class P2(Process):
        
        def __init__(self, pipe):
            self.pipe = pipe
            super(P2, self).__init__()
        def run(self):
            # recv
            print ('P2 recv ...')
            for i in range(3):
                i = self.pipe.recv()
                print ('recv: P2 -> %s' % i)
                
            # send
            print ('P2 send ...')
            for i in range(3):
                time.sleep(random.randint(1, 2))
                self.pipe.send(i)
                print ('send: P2 -> %s' % i)
    
    if __name__ == '__main__':
        # 创建Pipe
        pipe1, pipe2 = Pipe()
        p1 = P1(pipe1)
        p2 = P2(pipe2)
        p1.start()
        p2.start()
        p1.join()
        p2.join()
    创建一个Pipe会返回2个管道，这2个管道分别交给2个进
    程，即可实现这2个进程之间的互相通信。

***Event***  
如果需要在多进程之间控制某些事件的开始与停止，也就是在多进程进程保持同步信号信息，可使用Event

import time
    import random
    from multiprocessing import Process, Queue, Event
    
    class P1(Process):
    
        def __init__(self, queue,event):
            self.queue = queue
            self.event = event
            super(P1,self).__init__()
    
        def run(self):
            #阻塞 等待主进程进入
            self.event.wait()
            print('P1 put ...')
            for i in range(5):
                time.sleep(random.randint(1,3))
                self.queue.put(i)
                print('put: P1->%s'%i)
    
    class P2(Process):
        def __init__(self, queue, event):
            self.queue = queue
            self.event = event
            super(P2, self).__init__()
        def run(self):
            # 阻塞 等待主进程信号
            self.event.wait()
            print ('P2 read ...')
            while 1:
                i = self.queue.get()
                print ('get: P2 -> %s' % i)
    
    if __name__ == "__main__":
        #队列
        queue = Queue()
        #事件
        event = Event()
    
        p1 = P1(queue,event)
        p2 = P2(queue,event)
    
        p1.start()
        p2.start()
    
        #主进程让子进程阻塞了3秒
        print ('sleep 3s ...')
        time.sleep(3)
        # 向子进程发送信号 子进程向下执行
        event.set()
        p1.join()
        p2.terminate()
        
    执行程序后，我们发现2个子进程在执行到event.wait()时，阻塞在此，直到主进程休眠3秒后执行event.set()时，子进程才得以向下执行。
    
    使用Event可以控制进程之间的同步问题

***Lock***  
在执行多进程任务执行过程中，如果需要对同一资源（例如文件）进行访问时，为了防止一个进程操作的资源不被另一个进程篡改，可以使用Lock对其进行加锁互斥。

from multiprocessing import Process, Lock
    class P1(Process):
        def __init__(self, lock, fp):
            self.lock = lock
            self.fp = fp
            super(P1, self).__init__()
        def run(self):
            # 只有一个进程能进入操作
            with self.lock:
                for i in range(5):
                    f = open(self.fp, 'a+')
                    f.write('p1 - %s\n' % i)
                    f.close()
    class P2(Process):
        def __init__(self, lock, fp):
            self.lock = lock
            self.fp = fp
            super(P2, self).__init__()
        def run(self):
            # 只有一个进程能进入操作
            with self.lock:
                for i in range(5):
                    f = open(self.fp, 'a+')
                    f.write('p2 - %s\n' % i)
                    f.close()
                    
    if __name__ == '__main__':
        # 进程锁
        lock = Lock()
        fp = 'test.txt'
        p1 = P1(lock, fp)
        p2 = P2(lock, fp)
        p1.start()
        p2.start()
        p1.join()
        p2.join()
    如果想保证写入顺序，在写文件之前使用Lock加锁，就
    能保证只有一个进程能进入操作文件。