python的进程

        由于GIL的存在，python中的多线程其实并不是真正的多线程，如果想要充分地使用多核CPU的资源，在python中大部分情况需要使用多进程。Python提供了非常好用的多进程包multiprocessing，只需要定义一个函数，Python会完成其他所有事情。借助这个包，可以轻松完成从单进程到并发执行的转换。multiprocessing支持子进程、通信和共享数据、执行不同形式的同步，提供了Process、Queue、Pipe、Lock等组件。

　　multiprocessing包是Python中的多进程管理包。与threading.Thread类似，它可以利用multiprocessing.Process对象来创建一个进程。该进程可以运行在Python程序内部编写的函数。该Process对象与Thread对象的用法相同，也有start(), run(), join()的方法。此外multiprocessing包中也有Lock/Event/Semaphore/Condition类 (这些对象可以像多线程那样，通过参数传递给各个进程)，用以同步进程，其用法与threading包中的同名类一致。所以，multiprocessing的很大一部份与threading使用同一套API，只不过换到了多进程的情境。

 

但在使用这些共享API的时候，我们要注意以下几点:

在UNIX平台上，当某个进程终结之后，该进程需要被其父进程调用wait，否则进程成为僵尸进程(Zombie)。所以，有必要对每个Process对象调用join()方法 (实际上等同于wait)。对于多线程来说，由于只有一个进程，所以不存在此必要性。multiprocessing提供了threading包中没有的IPC(比如Pipe和Queue)，效率上更高。应优先考虑Pipe和Queue，避免使用Lock/Event/Semaphore/Condition等同步方式 (因为它们占据的不是用户进程的资源)。多进程应该避免共享资源。在多线程中，我们可以比较容易地共享资源，比如使用全局变量或者传递参数。在多进程情况下，由于每个进程有自己独立的内存空间，以上方法并不合适。此时我们可以通过共享内存和Manager的方法来共享资源。但这样做提高了程序的复杂度，并因为同步的需要而降低了程序的效率。

Process.PID中保存有PID，如果进程还没有start()，则PID为None。

window系统下，需要注意的是要想启动一个子进程，必须加上那句if __name__ == "main"，进程相关的要写在这句下面。

1.进程的调用

         进程调用方式和线程一样，也分为直接调用和类方法调用：

直接调用：

from multiprocessing import Process import os def func(num): print ('我是%s'%num) print('我的进程号',os.getpid()) if __name__ == '__main__': L = [] for i in range(20): p = Process(target=func,args=(i,)) L.append(p) p.start() for l in L: l.join() print('ending...') View Code

类方法调用：

from multiprocessing import Process import os class MyProcess(Process): def __init__(self,num): super(MyProcess,self).__init__() self.num = num def run(self): print('我是%s'%self.num) print('父进程PID号是',os.getppid()) print('我的pid号是',self.pid) if __name__ == '__main__': L = [] print('main',os.getpid()) for i in range(20): p = MyProcess(i) L.append(p) p.start() for l in L: l.join() View Code

2.Process类

构造方法： Process([group [, target [, name [, args [, kwargs]]]]]) 　　group: 线程组，目前还没有实现，库引用中提示必须是None； 　　target: 要执行的方法； 　　name: 进程名； 　　args/kwargs: 要传入方法的参数。 实例方法： 　　is_alive()：返回进程是否在运行。 　　join([timeout])：阻塞当前上下文环境的进程程，直到调用此方法的进程终止或到达指定的timeout（可选参数）。 　　start()：进程准备就绪，等待CPU调度 　　run()：strat()调用run方法，如果实例进程时未制定传入target，这star执行t默认run()方法。 　　terminate()：不管任务是否完成，立即停止工作进程 属性： 　　authkey 　　daemon：和线程的setDeamon功能一样 　　exitcode(进程在运行时为None、如果为–N，表示被信号N结束） 　　name：进程名字。 　　pid：进程号。

3.进程通信

        从一开始讲概念我们知道，线程之前是共享进程里面的数据集的，所以线程之间的通信是比较方便的，进程之前没有这个数据集，那应该怎么通信呢？回想之前的线程有线程队列，进程是不是也有进程的队列呢？那肯定是有的：

进程队列：

import multiprocessing def Foo(q): print(q.get()) print(q.get()) print(q.get()) if __name__ == '__main__': L = [] queue = multiprocessing.Queue() p = multiprocessing.Process(target=Foo,args=(queue,)) p.start() queue.put({'name:pengfy'}) queue.put([1,2,3,4,5]) queue.put('qaq') p.join() #注意join放的位置 View Code

        这里主进程放置了3三元素到队列，子进程取到并打印出来了，这就是一次简单的进程间的通信，这里要注意join的位置。

进程管道：

         管道Pipe（）函数返回一个由管道连接的连接对象（类似socket通信里面的conn），默认情况下是双工（双向）：

#管道，类似socket里面的conn # from multiprocessing import Process,Pipe def connect(conn): conn.send([12, {"name":"pengfy"}, 'hello']) print(conn.recv()) conn.close() print('son2', id(conn)) if __name__ == "__main__": parent_conn,child_conn = Pipe() #双向管道 print('son1',id(child_conn)) p = Process(target=connect,args=(child_conn,)) p.start() print(parent_conn.recv()) parent_conn.send('孩子你好') p.join() View Code

       看打印的id不一样，说明用的不是一份数据，是复制过去的。Pipe（）返回的两个连接对象代表管道的两端。 每个连接对象都有send（）和recv（）方法（以及其他方法）。 请注意，如果两个进程（或线程）同时尝试读取或写入管道的同一端，则管道中的数据可能会损坏。 当然，同时使用管道的不同端的进程不存在损坏的风险。

Manages

        上面两种类型，都是数据的传输，其实用的比较多的还是Manages（注意大小写）。Manager（）返回的管理器对象控制一个服务器进程，该进程保存Python对象并允许其他进程使用代理操作它们

View Code

        例子里面只列举了几种数据类型，总共支持的有list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Barrier, Queue, Value 和Array.

4.进程同步

       线程里面我们讲过线程同步，通过采用线程锁可以解决这个问题。那么进程有没有这个问题呢？肯定是有的，比如说：当进程共用一个资源时，需要同步，比如屏幕，不同步的话打印异常(用python2打印比较容易出现)

from multiprocessing import Process def func(i): print('hello',i) if __name__ == '__main__': L = [] for i in range(10): p = Process(target=func,args=(i,)) p.start() L.append(p) for l in L: l.join() View Code

 

       像这种情况，在进程里面也有一把锁来控制：

# from multiprocessing import Process,Lock # # def func(lock,i): # lock.acquire() # print('hello',i) # lock.release() # # # def func(lock,i): # # with lock: # # print('hello',i) # # if __name__ == '__main__': # lock = Lock() # L = [] # for i in range(10): # p = Process(target=func,args=(lock,i,)) # p.start() # L.append(p) # for l in L: # l.join() View Code

        这样怎么运行都不会出现上面那种情况了，不信可以试试。

5.进程池

       进程池是什么？就是一个池子，因为开多个进程比较容易消耗资源，所以需要控制同时执行的进程时，就可以用进程池来控制，进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进进程，那么程序就会等待，直到进程池中有可用进程为止。

进程池中有两个方法：

apply（同步接口，一般用不上）apply_async

看个例子：

from multiprocessing import Process,Pool import time,os def func(i): time.sleep(1) print(i) print("son",os.getpid()) return "HELLO %s"%i def tag(arg): #默认带有一个参数，是上面那个子进程的返回值 print(arg) if __name__ == '__main__': pool = Pool(5) print("main pid", os.getpid()) for i in range(100): # pool.apply(func=Foo, args=(i,)) #同步接口 # pool.apply_async(func=Foo, args=(i,)) # 回调函数： 就是某个动作或者函数执行成功后再去执行的函数,比如子进程运行完后都要打印log，就可以统一在回调函数里面操作 pool.apply_async(func=func, args=(i,), callback=tag) pool.close() pool.join() # join与close调用顺序是固定的 print('end') View Code

       里面涉及到一个回调函数的概念，就是某个动作或者函数执行成功后再去执行的函数，这个例子里面看的不明显，就是在每个进程执行完，都会打印一个数，你完全可以加在你的子进程函数里面去打印嘛，为什么还有用进程函数？当你每个进程，要需要做同一件事情的时候，就可以用回调函数了，这样消耗更小。

       进程的知识相对简单，线程和进程都说完了，还有内容吗？是的，还有一个协程的内容下一篇再说。

 

转载于:https://www.cnblogs.com/pengfy/p/10731531.html