python多线程、多进程、顺序执行在密集计算方面的表现差异示例

本文链接：https://blog.csdn.net/ypgsh/article/details/87004293

运行的函数，简单的计算程序：

def count(name, n):
    for i in range(n):
        a = 1 + 1
        b = a * 2
    print('{} finished!'.format(name))

分别通过多线程、多进程、顺序执行计算5次，比较差异，同时增加循环次数n，看随着循环增多，各种方式的表现

多进线程调用：

    t1 = time.time()
    a = Thread(target=count, args= ('thread',n))
    b = Thread(target=count, args=('thread',n))
    c = Thread(target=count, args=('thread',n))
    d = Thread(target=count, args=('thread',n))
    e = Thread(target=count, args=('thread',n))
    a.start()
    b.start()
    c.start()
    d.start()
    e.start()
    a.join()
    b.join()
    c.join()
    d.join()
    e.join()
    print('thread cost {}'.format(time.time() - t1))

多进程调用：

    t2 = time.time()
    p = Pool(2)
    p.apply_async(count, ('process',n))
    p.apply_async(count, ('process',n))
    p.apply_async(count, ('process',n))
    p.apply_async(count, ('process',n))
    p.apply_async(count, ('process',n))
    p.close()
    p.join()
    print('multiprocess cost {}'.format(time.time() - t2))

顺序执行：

    t3 = time.time()
    count('step',n)
    count('step',n)
    count('step',n)
    count('step',n)
    count('step',n)
    print('origin cost {}'.format(time.time() - t3))

结果：

n= 1000 0

thread cost 0.0134139060974

multiprocess cost 0.113832950592

origin cost 0.00221514701843

结论：多进程>多线程>顺序执行。

多进程：涉及到的资源多，在量比较小的时候，在资源调度上花费的额外消耗非常明显，多进程明显比顺序执行的时间还高。

多线程：由于GIL的存在(相当于单核执行)，且在GIL的获取以及释放方面有额外的开销，导致比顺序执行还慢。

n = 1000 000

thread cost 0.744644880295

multiprocess cost 0.328181028366

origin cost 0.283268928528

结论：多线程>多进程>顺序执行。

多进程：随着n变大，在调度上的损耗影响比重变小，比多线程更快了

多线程：由于先天劣势，仍然比顺序执行慢

n = 1000 000 0


thread cost 6.04525089264

multiprocess cost 1.66514611244

origin cost 2.33272981644

结论：多线程>顺序执行>多进程

多进程：随着n更大，在调度上的损耗影响比重更小，时间最快

多线程：由于先天劣势，仍然比顺序执行慢

*-*python的多线程一般用在io交互密集型的场景中，计算密集型场景就不要试了*-*