多进程multiprocessing模块

multiprocessing是python的多进程管理包，和threading.Thread类似。直接从侧面用subprocesses替换线程使用GIL的方式，由于这一点，multiprocessing模块可以让程序员在给定的机器上充分的利用CPU。

在multiprocessing中，通过创建Process对象生成进程，然后调用它的start()方法

from multiprocessing import Process

def f(name):
    print('hello', name)

if __name__ == '__main__':
    p = Process(target=f, args=('bob',))
    p.start()
    p.join()

和线程的方法都差不多

 daemon:

      daemon = True  不等待子线程完事就返回     

join:

     join(timeout=3)     等待线程3秒，超时后继续执行代码

#-*- coding:utf-8 -*-
from multiprocessing import Process
import time
def f(name):
    time.sleep(2)
    print('hello', name)

if __name__ == '__main__':
    p = Process(target=f, args=('p',))
    #默认Flase 等待子线程执行完毕，TRUE 不等待子线程完事
    #p.daemon = True
    p.start()
    p1 = Process(target=f, args=('p1',))
    p1.start()

    #等待3秒超时，超时过后才能继续执行
    p1.join(timeout=3)

    print("end")

 

进程间的数据操作

#-*- coding:utf-8 -*-
from multiprocessing import Process
import time

li = []

def foo(i):
    li.append(i)
    #查看进程中的li列表
    print("li:",li)



if __name__ == '__main__' :
 for i in range(10):
     p = Process(target=foo,args=(i,))
     p.start()
 '''结果：
 ('li:', [1])
('li:', [3])
('li:', [0])
('li:', [4])
('li:', [6])
('li:', [2])
('li:', [5])
('li:', [9])
('li:', [7])
('li:', [8])
 '''

进程间默认是无法通信的，如果向通信就通信 安全就完全无法保证

 

 

进程池

进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进进程，那么程序就会等待，直到进程池中有可用进程为止。

进程池中有两个方法：

• apply
• apply_async

# -*- coding:utf-8 -*-
from  multiprocessing import Process,Pool
import time

def Foo(i):
    time.sleep(1)
    print("Foo:%d"%i)
    return i+100

#Foo最后return 的值会传递到Bar的参数中。
def Bar(arg):
    print("callback:%d"%arg)



if __name__ == '__main__':
    pool = Pool(5)
    for i in range(10):
        #同步执行了每个进程都会join,也就是说串行执行等一个进程完毕后在执行下一个
        #pool.apply(Foo,(i,))

        #异步执行,callback可选,执行完子进程后将return结果带入到回调函数中。
        pool.apply_async(func=Foo, args=(i,),callback=Bar)

        #get方法获取异步执行函数的return结果
        #print pool.apply_async(func =Foo, args=(i,)).get()
    
    pool.close()
    #这个是对进程池操作,等待所有子进程完毕在关闭,如果注释主程序将不会等完子进程完事在退出，而是直接退出
    #执行这个方法之前必须执行pool.close()或 pool.terminate()关闭池
    pool.join()

pool下的join源码：

  def join(self):
        debug('joining pool')
        #状态是CLOSE或TERMINATE
        assert self._state in (CLOSE, TERMINATE)
        self._worker_handler.join()
        self._task_handler.join()
        self._result_handler.join()
        for p in self._pool:
            p.join()