要让Python程序实现多进程（multiprocessing），我们先了解操作系统的相关知识。
Unix/Linux操作系统提供了一个fork()系统调用，它非常特殊。普通的函数调用，调用一次，返回一次，但是fork()调用一次，返回两次，因为操作系统自动把当前进程（称为父进程）复制了一份（称为子进程），然后，分别在父进程和子进程内返回。
子进程永远返回0，而父进程返回子进程的ID。这样做的理由是，一个父进程可以fork出很多子进程，所以，父进程要记下每个子进程的ID，而子进程只需要调用getppid()就可以拿到父进程的ID。
Python的os模块封装了常见的系统调用，其中就包括fork，可以在Python程序中轻松创建子进程:
1 # /usr/bin/python
2 import os
3 import time
4
5
6 def main():
7 pid = os.fork()
8 if pid == 0: # 子进程中返回0
9 print("I am child process %d, my parent is %d" % (os.getpid(), os.getppid()))
10 time.sleep(1)
11 else: # 父进程中返回子进程id
12 print("I %d just created child %d" % (os.getpid(), pid))
13 time.sleep(1) # 防止父进程提前结束，子进程将由init进程接管，导致子进程中的os。getppid()输出的进程id是1
14
15 if __name__ == '__main__':
16 main()
程序运行结果：
1 I 20981 just created child 20982 2 I am child process 20982, my parent is 20981
由于Windows没有fork调用，上面的代码在Windows上无法运行。在Linux,Mac，Unix上都可以运行
有了fork调用，一个进程在接到新任务时就可以复制出一个子进程来处理新任务，常见的Apache服务器就是由父进程监听端口，每当有新的http请求时，就fork出子进程来处理新的http请求。
multiprocessing
如果你打算编写多进程的服务程序，Unix/Linux无疑是正确的选择。由于Windows没有fork调用，难道在Windows上无法用Python编写多进程的程序？
由于Python是跨平台的，自然也应该提供一个跨平台的多进程支持。multiprocessing模块就是跨平台版本的多进程模块。
multiprocessing模块提供了一个Process类来代表一个进程对象，下面的例子演示了启动一个子进程并等待其结束：
(1)Process类：
1 import multiprocessing
2 import os
3 import time
4
5
6 # 子进程要执行的代码
7 def run_process(i):
8 print("%d Child %s process run" % (i, multiprocessing.current_process().name, ))
9 time.sleep(1)
10 print("%d Child %s process end" % (i, multiprocessing.current_process().name,))
11
12
13 def main():
14 print("Process %d run" % (os.getpid()))
15 p1 = multiprocessing.Process(target=run_process, args=(1,)) # 和多线程Thread类创建实例相似
16 p1.start()
17 p1.join() # 主进程等待子进程结束
18 print("Process %d stop" % (os.getpid()))
19
20 if __name__ == '__main__':
21 main()
执行结果如下：
1 Process 22324 run 2 1 Child Process-1 process run 3 1 Child Process-1 process end 4 Process 22324 stop
创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，用start()方法启动，这样创建进程比fork()还要简单。
join()方法可以等待子进程结束后再继续往下运行，通常用于进程间的同步。
(2)Pool类：
在使用Python进行系统管理时，特别是同时操作多个文件目录或者远程控制多台主机，并行操作可以节约大量的时间。如果操作的对象数目不大时，还可以直接使用Process类动态的生成多个进程，十几个还好，但是如果上百个甚至更多，那手动去限制进程数量就显得特别的繁琐，此时Pool类就派上用场了。
Pool类可以提供指定数量的进程供用户调用，当有新的请求提交到Pool中时，如果池还没有满，就会创建一个新的进程来执行请求。如果池满，请求就会告知先等待，直到池中有进程结束，才会创建新的进程来执行这些请求。
1 import multiprocessing
2 import os
3 import time
4
5
6 def run_process(i):
7 print("%d Child %s process run at %s" % (i, multiprocessing.current_process().name, time.time()))
8 time.sleep(1)
9 print("%d Child %s process end" % (i, multiprocessing.current_process().name,))
10
11
12 def main():
13 print("Process %d run" % (os.getpid()))
14 p2 = multiprocessing.Pool(multiprocessing.cpu_count())
15 for i in range(5):
16 p2.apply_async(run_process, args=(i,)) # 该函数用于启动进程，传递不定参数，主进程是非阻塞且支持结果返回进行回调。
17 p2.close() # 关闭进程池（pool），使其不在接受新的任务。
18 p2.join() # 主进程阻塞等待子进程的退出，join方法必须在close或terminate之后使用。
19 print("Process %d stop" % (os.getpid()))
20
21 if __name__ == '__main__':
22 main()
运行结果：
1 Process 29676 run 2 0 Child SpawnPoolWorker-1 process run at 1487744098.910444 3 1 Child SpawnPoolWorker-3 process run at 1487744098.931447 4 2 Child SpawnPoolWorker-4 process run at 1487744098.936447 5 3 Child SpawnPoolWorker-2 process run at 1487744098.96145 6 0 Child SpawnPoolWorker-1 process end 7 4 Child SpawnPoolWorker-1 process run at 1487744099.911545 8 1 Child SpawnPoolWorker-3 process end 9 2 Child SpawnPoolWorker-4 process end 10 3 Child SpawnPoolWorker-2 process end 11 4 Child SpawnPoolWorker-1 process end 12 Process 29676 stop
代码解读：
对Pool对象调用join()方法会等待所有子进程执行完毕，调用join()之前必须先调用close()，调用close()之后就不能继续添加新的Process了。
请注意输出的结果，task 0，1，2，3是立刻执行的，而task 4要等待前面某个task完成后才执行，这是因为Pool的默认大小在我的电脑上是4，因此，最多同时执行4个进程。这是Pool有意设计的限制，并不是操作系统的限制。如果改成：
p2 = multiprocessing.Pool(5)
就可以同时跑5个进程。
由于Pool的默认大小是CPU的核数，如果你的电脑拥有8核CPU，你要提交至少9个子进程才能看到上面的等待效果。
pool类有一个map方法： def map(self, func, iterable, chunksize=None) 与内置的map函数用法行为基本一致，它会使进程阻塞直到返回结果：
1 def square(n): # 计算平方值
2 time.sleep(1) #计算一次休眠1s
3 print(n*n,time.time())
4 return n*n
5
6
7 def main():
8 print("Process %d run" % (os.getpid()))
9 number_list = [1, 2, 3, 4, 5, 6]
10 p2 = multiprocessing.Pool(multiprocessing.cpu_count()) # 本机4核CPU
11 p2.map(square, number_list)
12 print("Process %d stop" % (os.getpid()))
13
14 if __name__ == '__main__':
15 main()
运行结果：
1 Process 12264 run 2 1 1487744750.823629 3 4 1487744750.82863 4 9 1487744750.860633 5 16 1487744750.873634 6 25 1487744751.823729 7 36 1487744751.82873 8 Process 12264 stop
因为列表中共有6个元素，由于本机CPU有四核，在4个进程内的map方法同时可以对4个元素求平方，所以对于6个元素的列表，程序耗时2s。
由于map方法会使主进程阻塞，直到子进程返回，我们并没有调用p2.join(),主进程还是等待子进程结束
来源：https://www.cnblogs.com/z-joshua/p/6428837.html