Python多进程与多线程

并发进程

创建并发进程

1. 采用Process类创建子进程，通过join方法实现进程同步。

   import os
   from multiprocessing import Process
   
   
   def run_proc(name):
       print(f"Hello!I'm {name}.My pid is {os.getpid()} and my parent pid is {os.getppid()}")
   
   
   if __name__ == '__main__':
       print(os.getpid())
       pro = Process(target=run_proc,args=('apple',))
       pro.start()
       pro.join()
       print('end')
   

2. 调用进程池类 Pool，设置进程池大小，join方法使得子进程优先结算。

   import os
   from multiprocessing import Pool
   
   
   def run_proc(name):
       print(f"My pid is {name}.Start!")
       time.sleep(1)
       print(f"Process {name} ends!")
   
   
   if __name__ == '__main__':
       p = Pool(processes=3)
       for i in range(5):
           p.apply_async(run_proc,args=(str(i),))
       p.close()
       p.join()
       print('end')
   

进程通信

1. 使用安全队列Queue进行多个进程间的通信。其中由于读进程无限循环，需要手动终止。Queue的参数可以是各种类型。

   from multiprocessing import Process, Pool, Queue
   
   
   def pro_write(q, msg):
       q.put(msg)
       print(f"Write {msg}.")
       return
   
   
   def pro_read(q):
       print(f"Read message.")
       while True:
           msg = q.get()
           print(f"Read msg:{msg}.")
   
   
   if __name__ == '__main__':
       q = Queue()
       p_write1 = Process(target=pro_write,args=(q,['apple','banana','cat']))
       p_write2 = Process(target=pro_write,args=(q,1234))
       p_read = Process(target=pro_read,args=(q,))
       p_write1.start()
       p_write2.start()
       p_read.start()
       p_write1.join()
       p_write2.join()
       p_read.terminate()
   

2. 采用Pipe管道一对一传输方式（pipe如果接收不到数据会被阻塞，导致下边程序无法运行）：

   from multiprocessing import Process, Pool, Queue, Pipe
   
   
   def pro_send(pipe,msg):
       print(f"Send message.")
       for i in msg:
           print(f"Send message:{i}.")
           pipe.send(i)
           time.sleep(1)
       return
   
   
   def pro_recv(pipe):
       print(f"Receive message.")
       while True:
           print(f"Receive message:{pipe.recv()}")
           time.sleep(1)
   
   
   if __name__ == '__main__':
       pipe = Pipe()
       p_send = Process(target=pro_send,args=(pipe[0], [str(i) for i in range(5)],))
       p_recv = Process(target=pro_recv,args=(pipe[1],))
       p_send.start()
       p_recv.start()
       p_send.join()
       p_recv.join()
   

多线程

创建线程

1. 采用生成Thread类的方式创建线程。

   from threading import Thread
   
   
   def thread_run(msg):
       print(f"Current {threading.current_thread().name}")
       for i in msg:
           print(f"{threading.current_thread().name}-->{i},and pid is {os.getpid()}\n",end='')
           time.sleep(0.5)
   
   
   if __name__ == '__main__':
       t1 = Thread(target=thread_run,name='T1',args=(['apple','banana','cat'],))
       t2 = Thread(target=thread_run,name='T2',args=(['dog','fish','egg'],))
       t1.start()
       t2.start()
       t1.join()
       t2.join()
   

2. 继承Thread类，构造新类创建线程。

   class MyThread(threading.Thread):
       def __init__(self, name, msg):
           threading.Thread.__init__(self, name=name)
           self.msg = msg
   
       def run(self):
           print(f"Current {threading.current_thread().name}")
           for i in self.msg:
               print(f"{threading.current_thread().name}-->{i},and pid is {os.getpid()}\n", end='')
               time.sleep(0.5)
   
   
   if __name__ == '__main__':
       t1 = MyThread(name='T1', msg=['apple', 'banana', 'cat'])
       t2 = MyThread(name='T2', msg=['dog', 'fish', 'egg'])
       t1.start()
       t2.start()
       t1.join()
       t2.join()