Python multiprocessing 多进程 学习笔记

上一篇文章已经描述过线程和进程但简单关系: Python threading 多线程学习笔记

现在我们来看看多进程的学习


一、添加进程

添加进程和添加线程的代码差不多:

添加线程:(文件名为threading.py)

import threading as th

def job(a,d):
    print(a+d)
    print('aaaaa')

t=th.Thread(target=job,args=(2,3))  #Thread和Process的首字母都要大写,被调用的函数没有括号,被调用的函数的参数放在args(…)中
t.start()
t.join()

线程代码可以直接在python shell上直接运行,结果为:

============== RESTART: /Users/ziqi/Desktop/threading.py ==============
5
aaaaa
>>> 

添加进程:(文件名为p1.py)

import multiprocessing as mp

def job(a,d):
    print(a+d)
    print('aaaaa')

if __name__=='__main__':
    p1 = mp.Process(target=job,args=(1,2)) #Thread和Process的首字母都要大写,被调用的函数没有括号,被调用的函数的参数放在args(…)中
    p1.start()
    p1.join()

进程代码在python sell上面运行没有结果。需要在mac终端terminal上运行:

ziqi@ziqi~/Desktop  python p1.py
3
aaaaa


区别:

1.添加进程时, 在运用时需要添加上一个定义main函数的语句:if __name__=='__main__':

2.添加进程代码运行环境需要在 terminal环境下,可能其他的编辑工具会出现运行结束后没有打印结果。

二、 将运算结果存放到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,)) # args 的参数只要一个值的时候,参数后面需要加一个逗号,表示args是可迭代的,后面可能还有别的参数,不加逗号会出错
    p2 = mp.Process(target=job,args=(q,)) #定义两个线程函数,用来处理同一个任务
    #分别启动、连接两个线程
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    res1 = q.get() #上面是分两批处理的,所以这里分两批输出,将结果分别保存
    res2 = q.get()
    print(res1+res2) #打印最后的运算结果:499667166000


三、进程池pool

将运算的东西放进进程池中运算。

import multiprocessing as mp

def job(x): #这次进程调用的函数有了返回值,因为是放进Pool里面计算的
    return x*x 

def multicore():
	pool = mp.Pool() #Pool和之前的Process的不同点是丢向Pool的函数有返回值,而Process的没有返回值。
	res = pool.map(job,range(10)) #map()获取结果,在map()中需要放入函数和需要迭代运算的值,然后它会自动分配给CPU核,返回结果
	print(res)  #输出[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

if __name__=='__main__':
	multicore()

自定义核数量:

Pool默认大小是CPU的核数,我们也可以通过在Pool中传入processes参数即可自定义需要的核数量,

def multicore():
    pool = mp.Pool(processes=3) # 定义CPU核数量为3
    res = pool.map(job, range(10))
    print(res)

Pool除了map()外,还有可以返回结果的方式,那就是apply_async().

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

def multicore():
    pool = mp.Pool() 
    res = pool.map(job, range(10))
    print(res)
    res = pool.apply_async(job, (2,))
    # 用get获得结果
    print(res.get())

运行结果:

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]  # map()
4 # apply_async()

四、共享内存(shared memory)

只有用共享内存才能让CPU之间有交流,使进程都可以访问。

使用Value数据存储在一个共享的内存表中。

import multiprocessing as mp

value1 = mp.Value('i', 0) #i表示一个带符号的整型
value2 = mp.Value('d', 3.14) #d表示一个双精浮点类型

#共享数组:Array:只能是一维的,不能是多维的
array = mp.Array('i', [1, 2, 3, 4])

五、Lock进程锁

锁的存在是为了让进程能安全的访问共享数据。

1. 假设没有锁:

import multiprocessing as mp
import time

def job(v, num):
    for _ in range(5):
        time.sleep(0.1) # 暂停0.1秒,让输出效果更明显
        v.value += num # v.value获取共享变量值
        print(v.value)
        
def multicore():
    v = mp.Value('i', 0) # 定义共享变量
    p1 = mp.Process(target=job, args=(v,1))
    p2 = mp.Process(target=job, args=(v,10)) # 设定不同的number看如何抢夺内存
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    
if __name__ == '__main__':
    multicore()

输出结果为:

10
10
20
20
21
31
32
32
42
42
我们可以看到,进程1和进程2在相互抢着使用共享内存 v


2. 加进程锁:

import multiprocessing as mp
import time

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 multicore():
    v = mp.Value('i', 0)
    l = mp.Lock() # 定义一个进程锁
    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()

输出:

1
2
3
4
5
15
25
35
45
55


你可能感兴趣的:(python)