多进程

01最简单的使用

from multiprocessing import Pool

def f(x):
    return x*x
if __name__ == "__main__":
    p = Pool(5)
    print (p.man(f,[1,2,3]))

02子进程与父进程

我们知道父进程派生子进程 但是内存空间却是独立的 而子进程都是父进程通过fork方法过程

也就是 复制了一份 当容量比较大的程序 要慎重使用多线程

from multiprocessing import Process

import os

def info(title):
    print title
    print "module name:",__name__
    if hasattr(os,'getppid'):
        print 'parent process:',os.getppid()
    print 'process id:',os.getpid()

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

if __name__ == "__main__ ":
    info("main line")
    print "-----------"
    p = Process(target=f,args=('bob',))
    p.start()
    p.join()

03进程锁

类似多线程的线程锁，但是我们知道进程是独立的内存，工作不干扰的 那么这个功能没有太多用处，可能用在 多个进程同一平面输出

from multiprocessing import Process ,Lock
import  time
def f (l,i):

    l.acquire()
    print 'hello world',i
    l.release()

if __name__ =="__main__":
    lock =Lock()

    for num in range(10):
        Process(target=f,args=(lock,num)).start()

04 进程间通信 

进程是内存独立呢 那么如何进行进程间通信呢？就只有借助其他东西承载

也就是两个内存空间的桥梁

  【1】 Queue

from multiprocessing import Process ,Queue

def f(q,n):
    q.put([n,'hello'])
    
if __name__ == "__main__":
    q = Queue()
    for i in range(5):
        p = Process(target=f,args=(q,i))
        p.start()
    print q.get()

　　【2】Value and Array

from multiprocessing import Value,Array,Process
def f(n,a,raw):
    n.value = 3.15
    for i in range(5):
        a[i] = -a[i]
        raw.append(999)
        print raw
if __name__ =="__main__":
    num  = Value('d',0.0)
    arr  = Array('i',range(10))
    raw_list = range(10)
    print num.value
    print arr[:]
    p = Process(target=f,args=(num,arr,raw_list))
    p.start()
    p.join()

    print num.value
    print arr[:]

　　【3】manager

　

from multiprocessing import Manager ,Process

def f (d,l):
    d[1] = '1'
    d['2'] = 2
    d[0.25]= None
    l.reverse()

if  __name__ =="__main__":
    manager = Manager()

    d = manager.dict()
    l = manager.list(range(10))
    p = Process(target=f,args=(d,l))
    p.start()
    p.join()

    print d
    print l

manager 是比较慢的一种空间方式，但是能把字典传过去 而且manager还可以在两台不同主机间传递

05进程池-Pool

限制几个进程同时在运行 当然这也是一种启动进程的方法 

from multiprocessing import Pool
def f(x):
    return x+x

pool = Pool(processes=5)
res_list = []
for i in range(10):
    res = pool.apply_async(f,[i,])
    res_list.append(res)
for i in res_list:
    i.get()

apply_async -是异步的 apply是同步的 把进程启动了 还要等他完成