Python多进程multiprocessing（一）

介绍

上次介绍了如何在Python中使用多线程threading的内容，这一次我们来了解一下多进程multiprocessing的使用。网上有人把进程比作一个个车间，可以真正意义上实现同时处理多个任务，也就是多核运算（没错，这就要用到我们cpu的多核了）。在实际工作中，一般cpu 密集运算才用多进程，I/O 密集运算用多线程，而有没有必要上多线程多进程取决于数据量，因为对小任务可能适得其反。

使用实例

实例1

import multiprocessing as mp

def job(data):
    print('here shows the data:')
    print(data)

if __name__ == '__main__':
    data = [2019,12,31,10,59]
    p1 = mp.Process(target=job,args=(data,))
    p1.start()
    p1.join()

运行结果：

here shows the data:
[2019, 12, 31, 10, 59]

解释一下：

1. 这是最简单的一个sample，可以看出多进程的使用和多线程非常类似。注意，开局导入模块multiprocessing。
2. 创建Process对象p1，同时定义target任务和需要的参数，注意，这里（单个参数的情况）的data后面必须跟一个逗号（表明可迭代），不然会报错。
3. start方法用来开始执行该进程，join方法也与多进程中含义的一样。

实例2

import multiprocessing as mp

def job(q,data):
    res = sum(data)
    q.put(res)

if __name__ == '__main__':
    data = [i for i in range(1,101)]
    q = mp.Queue()
    p1 = mp.Process(target=job,args=(q,data[:50]))
    p2 = mp.Process(target=job,args=(q,data[50:]))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    res1 = q.get()
    res2 = q.get()
    print('res1:',res1)
    print('res2:',res2)
    print('sum:',res1+res2)

运行结果：

res1: 1275
res2: 3775
sum: 5050

解释一下：

1. 这个例子展示了一个很简单的使用两个进程分别输出不同数据的任务。
2. 由于target任务也是不能有return的，因此需要使用队列queue来存住和拿取结果，multiprocessing模块里已经自带了一个队列的类Queue，直接创建对象就可以了。
3. 队列Queue的方法中，put用来存结果，get用来取结果。

实例3

import multiprocessing as mp
import threading as td
from queue import Queue
import time

def _fn(data):
    res = 0
    for i in data:
        res += i + i**2 + i**3
    return res

def job(q,data):
    res = _fn(data)
    q.put(res)

def normal(data):
    res = _fn(data)
    print('normal res:',res)

def multicore(data):
    n = int(len(data) / 2)
    q = mp.Queue()
    p1 = mp.Process(target=job,args=(q,data[:n]))
    p2 = mp.Process(target=job,args=(q,data[n:]))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    res1 = q.get()
    res2 = q.get()
    res = res1 + res2
    print('multicore res:',res)

def multithread(q,data):
    n = int(len(data) / 2)
    t1 = td.Thread(target=job,args=(q,data[:n]))
    t2 = td.Thread(target=job,args=(q,data[n:]))
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    res1 = q.get()
    res2 = q.get()
    res = res1 + res2
    print('multithread res:',res)

if __name__ == '__main__':
    q = Queue()
    data = [i for i in range(1000000)]
    time1 = time.time()
    normal(data)
    time2 = time.time()
    multithread(q,data)
    time3 = time.time()
    multicore(data,)
    time4 = time.time()

    print('normal time:',time2-time1)
    print('multithread time:',time3-time2)
    print('multicore time:',time4-time3)

运行结果：

normal res: 249999833333583333000000
multithread res: 249999833333583333000000
multicore res: 249999833333583333000000
normal time: 0.8159060478210449
multithread time: 0.8133928775787354
multicore time: 0.7014920711517334

解释一下：

1. 这个例子对比了一下使用三种方法（普通，多线程，多进程）来执行同一个任务的效率。
2. 从时间结果看，普通方法和多线程差不多，多核心的更快一点。
3. 注意这里定义的任务是相对运算较复杂的，如果用简单的任务，可能普通方法会更快一点。

未完待续

第二部分内容请查看

Python多进程multiprocessing（一）

原文：https://www.cnblogs.com/mrdoghead/p/12124757.html