【Python】周莫烦-Multiprocessing 让你的多核计算机发挥真正潜力【笔记】

视频地址：Multiprocessing 让你的多核计算机发挥真正潜力

多线程缺点，同一时间只有一个线程进行，多进程的话真正的同时运行计算

创建进程

需要在cmd窗口运行才能显示多进程的结果

import multiprocessing as mp
import threading as td

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

if __name__=='__main__':
    #多进程和多线程语法类似
    #t1 = td.Thread(target=job,args=(1,2))
    p1 = mp.Process(target=job,args=(1,2))
    #t1.start()
    p1.start()
    #多进程和多进程join用法相同
    #t1.join()
    p1.join()

quere进程输出

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()
    #要把q放入参数中,若只有q一个参数，一定要加逗号，否则会报错
    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
import threading as td
import time

def job(q):
    res = 0
    for i in range(1000000):
        res += i+i**2+i**3
    q.put(res)
    
def multcore():
    q = mp.Queue()
    #要把q放入参数中,若只有q一个参数，一定要加逗号，否则会报错
    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('multicore:',res1+res2)

def normal():
    res = 0
    for _ in range(2):
        for i in range(1000000):
            res += i+i**2+i**3
    print('normal:',res)

def multithread():
    q = mp.Queue()
    #要把q放入参数中,若只有q一个参数，一定要加逗号，否则会报错
    t1 = td.Thread(target=job,args=(q,))
    t2 = td.Thread(target=job,args=(q,))
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    res1 = q.get()
    res2 = q.get()
    print('multithread:',res1+res2)

if __name__=='__main__':
    st = time.time()
    normal()
    st1 = time.time()
    print('normal time:',st1 - st)
    multithread()
    st2 = time.time()
    print('multithread time:',st2 - st1)
    multcore()
    st3 = time.time()
    print('multicode time:',st3 - st2)

进程池pool

进程池把所有的要运行的东西，放到池子里面，python会负责分配进程、运出结果
map可以放入很多个可以迭代的参数，自动分配给每个进程
apply_async一次只能在一个进程中间算一个东西，所想达到map效果，需要用到迭代效应，然后再用迭代把值传出来

import multiprocessing as mp

def job(x):
    return x*x
    
def multcore():
    #默认为所有核，也可以自定义使用的核数,但实测好像都是调用了所有核
    pool = mp.Pool(processes=2)
    res = pool.map(job,range(10))
    print(res)
    #只能给1个值，只放进1个核里运算
    res = pool.apply_async(job,(2,))
    print(res.get())
    #若想放进很多个值，用迭代器
    multi_res=[pool.apply_async(job,(i,)) for i in range(10)]
    print([res.get() for res in multi_res])

if __name__=='__main__':
    multcore()

共享内存

#'i'为整数，'d'为双精度
#后面的为设置的值
value = mp.Value('i',1)
#定义多个值，只能是一维的列表，否则会报错
array = mp.Array('i',[1,2,3])

锁Lock

要用cmd命令窗运行，否则会不显示结果
若不用Lock，会两个轮流用v
若用Lock，则会等p1运行完后，在运行p2
注意：要将Lock当作参数传入

import multiprocessing as mp
import time

def job(v, num,l):
    l.acquire()
    for _ in range(10):
        time.sleep(0.1)
        #摄取共享内存
        v.value += num
        print(v.value)
    l.release()
        
def multicore():
    #
    l = mp.Lock()
    v = mp.Value('i', 0) # 定义共享变量
    #要将Lock传入
    p1 = mp.Process(target=job, args=(v,1,l))
    p2 = mp.Process(target=job, args=(v,3,l)) # 设定不同的number看如何抢夺内存
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    
if __name__ == '__main__':
    multicore()