引言

讲到进程，不得不先说下linux的fork()函数，一个进程调用fork（）函数后，系统先给新的进程分配资源，例如存储数据和代码的空间。然后把原来的进程的所有值都复制到新的新进程中，只有少数值与原来的进程的值不同。相当于克隆了一个自己。

import os
import time
# 此代码只能运行于linux/unix
pid = os.fork() # 创建一个子进程
print("test")
if pid == 0:
    print("子进程 {}, 父进程是 {}".format(os.getpid(), os.getppid()))
else:
    print("我是父进程: {}".format(pid))
time.sleep(2)
# 执行结果
# test
# 我是父进程: 6428
# test
# 子进程
# 6428, 父进程是 6427

注意到，fork()后面的代码执行了两次，但行为不一样。如果fork()返回0，说明是子进程。而子进程会将父进程的数据原样拷贝一遍，所以和线程不一样，不能通过全局变量来通信。

由于GIL锁的存在，python的多线程一直被人诟病，在CPU密集型操作中，推荐多进程，在IO密集型操作中，推荐多线程。和多线程的threading模块一样，python为多进程也提供了multiprocessing多进程包。

multiprocessing模块

有了多线程的使用基础，多进程的API很好理解。

普通使用

import multiprocessing
import time
def get_html(n):
    time.sleep(n)
    print("sub_progress success")
    return n

if __name__ == "__main__": #注意，在windows下这句话必须加！！！
    progress = multiprocessing.Process(target=get_html, args=(2,))
    print(progress.pid)
    progress.start() # 启动子进程
    print(progress.pid) # 打印子进程的PID
    progress.join() # 等待子进程结束
    print("main progress end")
# 执行结果
# None
# 5444
# sub_progress success
# main progress end

multiprocessing.Process()传入执行入口函数和参数。
start()方法启动子进程。
progress.pid属性可以获取子进程的ID号，在未启动前，未None，启动后，得到系统分配的ID号。
join()方法等待子进程结束。

进程池

multiprocessing模块中提供Pool类来支持进程池编程。

import multiprocessing
import time
def get_html(n):
    time.sleep(n)
    print("sub_progress success")
    return n

if __name__ == "__main__": #注意，在windows下这句话必须加！！！
    pool = multiprocessing.Pool(multiprocessing.cpu_count())
    result = pool.apply_async(get_html, args=(3,))

    pool.close() # 在join前必须运行close()
    pool.join()
    print(result.get()) # 得到子进程的返回值
# 执行结果  
# sub_progress success
# 3

使用multiprocessing.Pool()来创建进程池，可以设置进程池的大小，默认为CPU的核心个数，一般进程也不会超过CPU的核心个数，超过了效率也不会高。
apply_async方法传入执行入口函数和参数，传入之后，就进入了子进程等待队列中，等待执行。返回值是ApplyResult对象，存储子进程的结果。
join()方法等待所有子进程的结束，调用前必须使用close()方法。
ApplyResult对象的get()方法，获取子进程的返回值。

multiprocessing模块同样提供了类似于map的方法：

import multiprocessing
import time
def get_html(n):
    time.sleep(n)
    print("{}s sub_progress success".format(n))
    return n

if __name__ == "__main__": #注意，在windows下这句话必须加！！！
    pool = multiprocessing.Pool(multiprocessing.cpu_count())
    # for result in pool.imap_unordered(get_html, [1, 3, 2]):
    for result in pool.imap(get_html, [1, 3, 2]):
        print("{}s sleep success".format(result))
# 执行结果
# 1s sub_progress success
# 1s sleep success
# 2s sub_progress success
# 3s sub_progress success
# 3s sleep success
# 2s sleep success

imap方法，结果输出顺序与传入的可迭代对象的顺序相同。
imap_unordered方法，结果输出顺序与子进程结束的时间顺序相同。

进程池的更好实现

虽然multiprocessing模块中提供Pool类，但是使用进程池的时候，使用concurrent.futures模块中的ProcessPoolExecutor类更加方便。在介绍线程池的时候，介绍了ThreadPoolExecutor的使用，而ProcessPoolExecutor的接口实现和ThreadPoolExecutor完全一样，只用多创建多线程改完创建多进程即可。值得注意的是：在windows下进行多进程编程的时候，主程序一定要加if __name__ == "__main__":。

总结

在CPU密集型操作时，使用多进程可以加快速度。
多进程API与多线程API基本相同，在使用线程池的时候，可以使用multiprocessing.Pool，也可以使用Future模块下的ProcessPoolExecutor，推荐后者。
在windows下多进程编程要加if __name__ == "__main__":。