python 多进程

**

基础版：

python多线程效果不是太理想，本节就讲述一些python多进程的基础内容
1 Process
以代码为例：

import multiprocessing as mp

def job(a,d):
    print('aaaaa')   #Process 对应的target无返回

if __name__=='__main__':
    p1 = mp.Process(target=job,args=(1,2))
    p1.start()
    p1.join()

Process多进程需要传入target=job,args=(1,2)两个参数即可。

2 Queue
Queue的功能是将每个核或线程的运算结果放在队里中， 等到每个线程或核运行完毕后再从队列中取出结果， 继续加载运算。原因很简单, 多线程调用的函数不能有返回值, 所以使用Queue存储多个线程运算的结果

import multiprocessing as mp

def job(q):
    res=0
    for i in range(1000):
        res+=i+i**2+i**3
    q.put(res)    #queue

if __name__=='__main__':
    q = mp.Queue()
    p1 = mp.Process(target=job,args=(q,))
    p2 = mp.Process(target=job,args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    res1 = q.get()
    res2 = q.get()
    print(res1+res2)

3 Pool

Pool可以用map 和apply_async() 进行处理

import multiprocessing as mp  

def job(x): 
    return x*x   #可以有返回
def multicore():
    pool = mp.Pool()
    res = pool.map(job, range(10))  #map对应的是list
    print(res)
    
if __name__ == '__main__':
    multicore()

相比较于map，apply_async()中只能传递一个值，它只会放入一个核进行运算，但是传入值时要注意是可迭代的，所以在传入值后需要加逗号, 同时需要用get()方法获取返回值

import multiprocessing as mp  

def job(x): 
    return x*x   #可以有返回
def multicore():
    pool = mp.Pool() 
    res = pool.map(job, range(10))
    print(res)
    res = pool.apply_async(job, (2,))
    # 用get获得结果
    print(res.get())
    
if __name__ == '__main__':
    multicore()

可以通过[pool.apply_async(job, (i,)) for i in range(10)]进行解决apply_async()中只能传递一个值的缺点。

def multicore():
    pool = mp.Pool() 
    res = pool.map(job, range(10))
    print(res)
    res = pool.apply_async(job, (2,))
    # 用get获得结果
    print(res.get())
    # 迭代器，i=0时apply一次，i=1时apply一次等等
    multi_res = [pool.apply_async(job, (i,)) for i in range(10)]
    # 从迭代器中取出
    print([res.get() for res in multi_res])

4 进程锁
为了解决不同进程抢共享资源的问题，我们可以用加进程锁来解决。

def job(v, num, l):
    l.acquire() # 锁住
    for _ in range(5):
        time.sleep(0.1) 
        v.value += num # v.value获取共享内存
        print(v.value)
    l.release() # 释放
    
def job(v, num, l):
    l.acquire() # 锁住
    for _ in range(5):
        time.sleep(0.1) 
        v.value += num # 获取共享内存
        print(v.value)
    l.release() # 释放

def multicore():
    l = mp.Lock() # 定义一个进程锁
    v = mp.Value('i', 0) # 定义共享内存
    p1 = mp.Process(target=job, args=(v,1,l)) # 需要将lock传入
    p2 = mp.Process(target=job, args=(v,3,l)) 
    p1.start()
    p2.start()
    p1.join()
    p2.join()

if __name__ == '__main__':
    multicore()

参考文献https://morvanzhou.github.io/tutorials/python-basic/multiprocessing/

进阶

待有时间再更新深层多进程的使用方法，在此Mark一下。