多进程

01最简单的使用

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

02子进程与父进程

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

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

 1 from multiprocessing import Process
 2 
 3 import os
 4 
 5 def info(title):
 6     print title
 7     print "module name:",__name__
 8     if hasattr(os,'getppid'):
 9         print 'parent process:',os.getppid()
10     print 'process id:',os.getpid()
11 
12 def f(name):
13     info('funtion f')
14     print 'hello',name
15 
16 if __name__ == "__main__ ":
17     info("main line")
18     print "-----------"
19     p = Process(target=f,args=('bob',))
20     p.start()
21     p.join()

03进程锁

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

 1 from multiprocessing import Process ,Lock
 2 import  time
 3 def f (l,i):
 4 
 5     l.acquire()
 6     print 'hello world',i
 7     l.release()
 8 
 9 if __name__ =="__main__":
10     lock =Lock()
11 
12     for num in range(10):
13         Process(target=f,args=(lock,num)).start()

04 进程间通信

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

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

【1】 Queue

 1 from multiprocessing import Process ,Queue
 2 
 3 def f(q,n):
 4     q.put([n,'hello'])
 5     
 6 if __name__ == "__main__":
 7     q = Queue()
 8     for i in range(5):
 9         p = Process(target=f,args=(q,i))
10         p.start()
11     print q.get()

　　【2】Value and Array

 1 from multiprocessing import Value,Array,Process
 2 def f(n,a,raw):
 3     n.value = 3.15
 4     for i in range(5):
 5         a[i] = -a[i]
 6         raw.append(999)
 7         print raw
 8 if __name__ =="__main__":
 9     num  = Value('d',0.0)
10     arr  = Array('i',range(10))
11     raw_list = range(10)
12     print num.value
13     print arr[:]
14     p = Process(target=f,args=(num,arr,raw_list))
15     p.start()
16     p.join()
17 
18     print num.value
19     print arr[:]

　　【3】manager

 1 from multiprocessing import Manager ,Process
 2 
 3 def f (d,l):
 4     d[1] = '1'
 5     d['2'] = 2
 6     d[0.25]= None
 7     l.reverse()
 8 
 9 if  __name__ =="__main__":
10     manager = Manager()
11 
12     d = manager.dict()
13     l = manager.list(range(10))
14     p = Process(target=f,args=(d,l))
15     p.start()
16     p.join()
17 
18     print d
19     print l

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

05进程池-Pool

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

 1 from multiprocessing import Pool
 2 def f(x):
 3     return x+x
 4 
 5 pool = Pool(processes=5)
 6 res_list = []
 7 for i in range(10):
 8     res = pool.apply_async(f,[i,])
 9     res_list.append(res)
10 for i in res_list:
11     i.get()

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