python 多线程和多进程2

1.    多进程 multiprocessing模块

　　python中由于GIL锁的存在使多线程并非真正的多线程，所以为了充分利用多核CPU，在python中大部分情况下需要使用多进程。

　　（1）Process类调用

from multiprocessing import Process
import os

def run_proc(name):
    print('run child process %s (%s)...' % (name, os.getpid()))

if __name__ == '__main__':
    print('parent process %s.' %os.getpid())
    p = Process(target=run_proc,args=('test',))
    print('child process will start')
    p.start()
    p.join()
    print('child process end.')

　　（2）进程队列Queue，进程间通讯数据传递

from multiprocessing import Process,Queue

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

if __name__ == '__main__':
    q = Queue()
    for i in range(5):
        p = Process(target=f,args=(q,i))
        p.start()

　　（3）进程Manager，进程间数据共享

from multiprocessing import Process,Manager
#使用manager实现进程共享
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))  #生成一个列表，可以在进程间共享和传递
    print(d)
    print(l)
    for i in range(10):
        p = Process(target=f,args=(d,l))
        p.start()
        p.join()
    print(d)
    print(l)

　　（4）进程锁

from multiprocessing import Process,Lock
#进程锁
def f(l,i):
    l.acquire()
    print('how are you',i)
    l.release()

if __name__ == '__main__':
    lock = Lock()
    for num in range(10):
        p = Process(target=f,args=(lock,num))
        p.start()
        p.join()

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

from multiprocessing import Pool
import time
#使用pool产生多进程
def f(x):
    print(x*x)
    time.sleep(2)
    return x*x
pool = Pool(processes=5)
res_list = []
for i in range(10):
    res = pool.apply_async(f,[i,])
pool.close()          #等待子进程执行完毕关闭进程池
pool.join()
    

　　进程池中所用到的方法：

　　　　a.  apply：从进程池中取一个进程并执行

　　　　b.  apply_async：apply的异步

　　　　c.  terminate：立刻关闭进程池

　　　　d.  join：主进程等待子进程执行完毕，必须在close或terminate之后

　　　　e.  close：等待所有进程结束后，关闭进程池