Python多进程（multiprocessing）

Unix/Linux操作系统提供了一个fork()系统调用，它非常特殊。普通的函数调用，调用一次，返回一次，但是fork()调用一次，返回两次，因为操作系统自动把当前进程（称为父进程）复制了一份（称为子进程），然后，分别在父进程和子进程内返回。

子进程永远返回0，而父进程返回子进程的ID。这样做的理由是，一个父进程可以fork出很多子进程，所以，父进程要记下每个子进程的ID，而子进程只需要调用getppid()就可以拿到父进程的ID。

Python的os模块封装了常见的系统调用，其中就包括fork，可以在Python程序中轻松创建子进程

由于Windows没有fork调用，上面的代码在Windows上无法运行。由于Mac系统是基于BSD（Unix的一种）内核，所以，在Mac下运行是没有问题的，

有了fork调用，一个进程在接到新任务时就可以复制出一个子进程来处理新任务，常见的Apache服务器就是由父进程监听端口，每当有新的http请求时，就fork出子进程来处理新的http请求。

在Windows下通过multiprocessing模块实现

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

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

例子

直接调用

 from multiprocessing import Process
 import time
 def f(name):
     time.sleep(1)
     print('hello', name,time.ctime())

 if __name__ == '__main__':
     p_list=[]
     for i in range(3):
         p = Process(target=f, args=('alvin',))
         p_list.append(p)
         p.start()
     for i in p_list:
         p.join()
     print('end')

继承（类）式调用

 from multiprocessing import Process
 import time

 class MyProcess(Process):
     def __init__(self):
         super(MyProcess, self).__init__()
         #self.name = name

     def run(self):
         time.sleep(1)
         print ('hello', self.name,time.ctime())

 if __name__ == '__main__':
     p_list=[]
     for i in range(3):
         p = MyProcess()
         p.start()
         p_list.append(p)

     for p in p_list:
         p.join()

     print('end')

获取进程pid

 from multiprocessing import Process
 import time
 import os

 def info(title):
     print(title)
     print('module name:', __name__)
     print('parent process:', os.getppid())  # 获取父进程pid
     print('process id:', os.getpid())     # 获取子进程pid

 def f(name):
     info('\033[31;1mfunction f\033[0m')
     print('hello', name)

 if __name__ == '__main__':    # windows下多进程必须有这句
     info('\033[32;1mmain process line\033[0m')
     time.sleep(5)
     p = Process(target=info, args=('bob',))
     p.start()
     p.join()
 print('end', __name__)

输出为

 main process line
 module name: __main__
 parent process: 10704
 process id: 216
 end __mp_main__
 bob
 module name: __mp_main__
 parent process: 216
 process id: 7612
 end __main__

Process类

Process类的__init__

class Process(object):
    def __init__(self, group=None, target=None, name=None, args=(), kwargs={}):
        self.name = ''
        self.daemon = False
        self.authkey = None
        self.exitcode = None
        self.ident = 0
        self.pid = 0
        self.sentinel = None

　　target:要执行的方法

　　name:进程名

　　args/kwargs:要传入的方法

实例方法

　　is_alive()：返回进程是否在运行。

　　join([timeout])：阻塞当前上下文环境的进程程，直到调用此方法的进程终止或到达指定的timeout（可选参数）。

　　start()：进程准备就绪，等待CPU调度

　　run()：strat()调用run方法，如果实例进程时未制定传入target，这star执行t默认run()方法。

　　terminate()：不管任务是否完成，立即停止工作进程

属性

　　daemon：和线程的setDeamon功能一样

　　exitcode(进程在运行时为None、如果为–N，表示被信号N结束）

　　name：进程名字。

　　pid：进程号。

进程间通信

不同进程间内存是不共享的，要实现两个进程间的数据交换

Queues

使用方法与threading里的queue类似

 from multiprocessing import Process, Queue

 def f(q,n):
     q.put([42, n, 'hello'])

 if __name__ == '__main__':
     q = Queue()
     p_list=[]
     for i in range(3):
         p = Process(target=f, args=(q,i))
         p_list.append(p)
         p.start()
     print(q.get())
     print(q.get())
     print(q.get())
     for i in p_list:
             i.join()

Pipe(管道)

multiprocessing.Pipe([duplex])

返回2个连接对象(conn1, conn2),代表管道的两端,默认是双向通信.如果duplex=False,conn1只能用来接收消息,conn2只能用来发送消息.默认duplex = True

可用于多个对象通信，即建立多个子进程

 import os

 from multiprocessing import Process, Pipe

 def f(conn):
     conn.send('约吗')
     print(conn.recv(),'in the %s' % os.getpid())
     conn.close()

 if __name__ == '__main__':
     parent_conn, child_conn = Pipe()
     p = Process(target=f, args=(child_conn,))
     p2 = Process(target=f, args=(child_conn,))
     p.start()
     p2.start()
     print(parent_conn.recv())  # prints "[42, None, 'hello']"
     print(parent_conn.recv())  # prints "[42, None, 'hello']"
     parent_conn.send('hello')
     parent_conn.send('hello2')

     p.join()

Manager

用于数据共享

Manager()返回的manager对象控制了一个server进程，此进程包含的python对象可以被其他的进程通过proxies来访问。从而达到多进程间数据通信且安全。

Manager支持的类型有list,dict,Namespace,Lock,RLock,Semaphore,BoundedSemaphore,Condition,Event,Queue,Value和Array。

 from multiprocessing import Process, Manager

 def f(d,l,n):
     d[n] = ''
     d[''] = 2
     d[0.25] = None
     l.append(n)
     #print(l)
     print('sub',id(d))

 if __name__ == '__main__':
     with Manager() as manager:#  with open() as f==   f=open()       manager=Manager()
         d = manager.dict()

         l = manager.list(range(5))
         p_list = []

         print('main',id(d))
         for i in range(10):
             p = Process(target=f, args=(d,l,i))
             p.start()
             p_list.append(p)

         for res in p_list:
             res.join()

         print(d)
         print(l)

进程池

进程池可用于一下子启动多个子进程

pool = Pool()

Pool()里面可以添加数字，默认是cpu核心数

 from  multiprocessing import Process, Pool
 import time
 import os

 def Foo(i):
     time.sleep(2)
     print('sub %s'%os.getpid())

     return i + 100

 def Bar(arg):
     print('Bar:',os.getpid())
     print('-->exec done:', arg)

 if __name__=='__main__':
     pool = Pool()
     print('main:',os.getpid())
     for i in range(10):
         pool.apply_async(func=Foo, args=(i,),callback=Bar)
         #pool.apply(func=Foo, args=(i,))
     print('end')

 from multiprocessing import Pool
 import os, time, random

 def long_time_task(name):
     print('Run task %s (%s)...' % (name, os.getpid()))
     start = time.time()
     time.sleep(random.random() * 3)
     end = time.time()
     print('Task %s runs %0.2f seconds.' % (name, (end - start)))

 if __name__=='__main__':
     print('Parent process %s.' % os.getpid())
     p = Pool(4)
     for i in range(5):
         p.apply_async(long_time_task, args=(i,))
     print('Waiting for all subprocesses done...')
     p.close()
     p.join()
     print('All subprocesses done.')