多进程的使用

多进程multiprocessing和多线程treading类似,都是用在python中进行并行计算的, 而多进程则是为了弥补Python在多线程中的劣势而出现的
mutiprocessing 是使用计算机的多核进行运算, 它可以避免多线程中GIL的影响
Python使用multiprocesssing模块实现多进程, 用法和threading基本一致

import multiprocessing as mp

"""
添加进程 multiprocessing.Process(target, args) 使用multiprocessing.Process新建一个进程, target是需要执行的函数, args是需要传入该函数的参数, args接受一个tuple, 即使只有一个参数也需要写成(x,)形式
"""
def job(a, d):
    print('aaaaa')

if __name__ == '__main__':
    p1 = mp.Process(target=job, args=(1, 2))  # 添加一个进程
    p1.start()
    p1.join()

信息传递：Queue队列
多进程中的Queue使用同多线程一致，同样为先进先出。
多进程可以直接从multiprocessing.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)    # 将值放入队列
 
if __name__=='__main__':
    q = mp.Queue() # 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)

进程池
import multiprocessing as mp
def job(x):
    return x*x
 
def multicore():
    pool = mp.Pool() # 定义一个进程池
    res = pool.map(job, range(100))
    print(res)
 
if __name__=='__main__':
    multicore()

进程锁
进程锁同线程锁使用方法一致，lock在不同进程使用同一共享内存时，能够确保进程之间互不影响。

使用lock的方法是：在每个进程执行运算修改共享内存之前执行lock.acquire()将共享内存上锁， 确保当前进程执行时，内存不会被其他进程访问；

执行运算完毕后使用lock.release()将锁打开， 保证其他的进程可以使用该共享内存。

lock.acquire()和lock.release()必须成对出现。 

import multiprocessing as mp
 
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()