写在前面：python中的多线程其实并不是真正的多线程，如果想要充分地使用多核CPU的资源，在python中大部分情况需要使用多进程。Python提供了非常好用的多进程包multiprocessing，只需要定义一个函数，Python会完成其他所有事情。借助这个包，可以轻松完成从单进程到并发执行的转换。
1.multiprocessing模块提供了一个Process类来代表一个进程对象
import os
import time
import multiprocessing
def run_proc(name): # 子进程要执行的代码
print '运行子进程 %s ，子进程号为(%s)...' % (name, os.getpid())
print "我的处理内容是：%s+%s=?" % (name,name)
return name
if __name__=='__main__':
start = time.time()
print '父进程号为 %s.' % os.getpid()
print('----------------------------------------')
job = []
for i in range(3):
p = multiprocessing.Process(target=run_proc, args=(i,))#多进程
job.append(p)
print '子进程%d开启...'%i
p.start() #
print '子进程%d结束...' %i
print
#加join()可以让主线程一直等待全部的子线程结束之后，主线程自身才结束，程序退出
for t in job:
t.join()#join()方法可以等待子进程结束后再继续往下运行，通常用于进程间的同步
end = time.time()
print end-start
运行结果如下：
父进程号为 4924.
----------------------------------------
子进程0开启...
子进程0结束...
子进程1开启...
子进程1结束...
子进程2开启...
运行子进程 0 ，子进程号为(5516)...
我的处理内容是：0+0=?
运行子进程 1 ，子进程号为(5517)...
我的处理内容是：1+1=?
运行子进程 2 ，子进程号为(5523)...
我的处理内容是：2+2=?
子进程2结束...
0.0220789909363
如果想要返回多进程process处理得到的结果，只需要利用multiprocessing 中的Manager类即可，稍改代码：
import os
import time
from multiprocessing import Manager
def run_proc(name,return_list): # 子进程要执行的代码
print '运行子进程 %s ，子进程号为(%s)...' % (name, os.getpid())
print "我的处理内容是：%s+%s=?" % (name,name)
return_list.append(name)
if __name__=='__main__':
print '父进程号为 %s.' % os.getpid()
print('----------------------------------------')
manager = Manager()
return_list = manager.list()
#return_dict = manager.dict() 也可以使用字典dict
job = []
for i in range(3):
p = multiprocessing.Process(target=run_proc, args=(i,return_list))#多进程
job.append(p)
print '子进程%d开启...'%i
p.start()
print '子进程%d结束...' %i
print
for t in job:
t.join()
print "所有子进程处理得到的结果都在return_list中，值为：",return_list
运行结果如下：
父进程号为 4924.
----------------------------------------
子进程0开启...
子进程0结束...
子进程1开启...
子进程1结束...
子进程2开启...
运行子进程 0 ，子进程号为(5614)...
我的处理内容是：0+0=?
运行子进程 1 ，子进程号为(5616)...
我的处理内容是：1+1=?
运行子进程 2 ，子进程号为(5623)...
我的处理内容是：2+2=?
子进程2结束...
所有子进程处理得到的结果都在return_list中，值为： [0, 1, 2]
2.Pool：如果要启动大量的子进程，可以用进程池的方式批量创建子进程：
from multiprocessing import Pool
import os, time, random
def long_time_task(name):
print '运行任务 %s ，子进程号为(%s)...' % (name, os.getpid())
print "我就是子进程号为(%s)处理的内容" % (os.getpid())
start = time.time()
time.sleep(random.random() * 3)
end = time.time()
print '任务 %s 运行了 %0.2f 秒.' % (name, (end - start))
return name
if __name__=='__main__':
print '父进程号为 %s.' % os.getpid()
rst = []
p = Pool(4) #进程池中含有4个子进程
for i in range(5): #4个子进程完成5个任务，所以有一个任务是需要等某个进程空闲再处理
a = p.apply_async(long_time_task, args=(i,)) #a是进程处理函数long_time_task的返回结果
rst.append(a) #将次得到的结果添加到数组rst中去
print '等待所有子进程结束...'
p.close()
p.join()#等待所有子进程执行完毕。调用join()之前必须先调用close()，调用close()之后就不能继续添加新的Process了。
print '所有子进程结束...'
运行结果如下：
父进程号为 3378.
运行任务 0 ，子进程号为(4621)...
运行任务 2 ，子进程号为(4624)...
运行任务 1 ，子进程号为(4622)...
我就是子进程号为(4621)处理的内容
我就是子进程号为(4622)处理的内容
运行任务 3 ，子进程号为(4627)...
我就是子进程号为(4624)处理的内容
我就是子进程号为(4627)处理的内容
任务 1 运行了 0.16 秒.
运行任务 4 ，子进程号为(4622)...
我就是子进程号为(4622)处理的内容
等待所有子进程结束...
任务 2 运行了 0.98 秒.
任务 4 运行了 0.89 秒.
任务 3 运行了 2.25 秒.
任务 0 运行了 2.89 秒.
所有子进程结束...
直接输出rst不会得到想要的结果：
rst
运行结果：
[<multiprocessing.pool.ApplyResult at 0x7ffa6c682c90>,
<multiprocessing.pool.ApplyResult at 0x7ffa6c587590>,
<multiprocessing.pool.ApplyResult at 0x7ffa6c587610>,
<multiprocessing.pool.ApplyResult at 0x7ffa6c5876d0>,
<multiprocessing.pool.ApplyResult at 0x7ffa6c587790>]
这是需要用到.get()方法：
rst = [i.get() for i in rst]
rst
运行结果：
[0, 1, 2, 3, 4]