本文共 6796 字，大约阅读时间需要 22 分钟。
编写完毕的代码，在没有运行的时候，称之为程序。
正在运行着的代码，就称为进程。它除了包含代码以外，还有需要运行的环境等，所以它和程序有所区别
在Unix/Linux操作系统中，提供了一个fork()系统函数，它非常特殊。普通的函数调用，调用一次，返回一次，但是fork()调用一次，返回两次，因为操作系统自动把当前进程（称为父进程）复制了一份（称为子进程），然后，分别在父进程和子进程内返回。子进程永远返回0，而父进程返回子进程的ID。这样做的理由是，一个父进程可以fork出很多子进程，所以，父进程要记下每个子进程的ID，而子进程只需要调用getppid()就可以拿到父进程的ID。父进程、子进程执行顺序没有规律，完全取决于操作系统的调度算法
import os# 注意，fork函数，只在Unix/Linux/Mac上运行，windows不可以pid = os.fork()if pid == 0: print('哈哈1')else: print('哈哈2') multiprocessing模块就是跨平台版本的多进程模块，提供了一个Process类来代表一个进程对象。创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，用start()方法启动，这样创建进程比fork()还要简单。join()方法可以等待子进程结束后再继续往下运行，通常用于进程间的同步。
Process语法结构：
Process([group [, target [, name [, args [, kwargs]]]]])
target：表示这个进程实例所调用对象；
args：表示调用对象的位置参数元组；
kwargs：表示调用对象的关键字参数字典；
name：为当前进程实例的别名；
group：大多数情况下用不到；
Process类常用方法：
is_alive()：判断进程实例是否还在执行；
join([timeout])：是否等待进程实例执行结束，或等待多少秒；
start()：启动进程实例（创建子进程）；
run()：如果没有给定target参数，对这个对象调用start()方法时，就将执行对象中的run()方法；
terminate()：不管任务是否完成，立即终止；
Process类常用属性：
name：当前进程实例别名，默认为Process-N，N为从1开始递增的整数；
pid：当前进程实例的PID值；
#coding=utf-8from multiprocessing import Processimport os# 子进程要执行的代码def run_proc(name): print('子进程运行中，name= %s ,pid=%d...' % (name, os.getpid()))if __name__=='__main__': print('父进程 %d.' % os.getpid()) p = Process(target=run_proc, args=('test',)) print('子进程将要执行') p.start() p.join() print('子进程已结束') from multiprocessing import Processimport timeimport os#继承Process类class Process_Class(Process): def __init__(self,interval): Process.__init__(self) self.interval = interval #重写了Process类的run()方法 def run(self): print("子进程(%s) 开始执行，父进程为（%s）"%(os.getpid(),os.getppid())) t_start = time.time() time.sleep(self.interval) t_stop = time.time() print("(%s)执行结束，耗时%0.2f秒"%(os.getpid(),t_stop-t_start))if __name__=="__main__": t_start = time.time() print("当前程序进程(%s)"%os.getpid()) p1 = Process_Class(2) #对一个不包含target属性的Process类执行start()方法，就会运行这个类中的run()方法，所以这里会执行p1.run() p1.start() p1.join() t_stop = time.time() print("(%s)执行结束，耗时%0.2f"%(os.getpid(),t_stop-t_start)) 当需要创建的子进程数量达到上百甚至上千个目标，手动的去创建进程的工作量巨大，此时就可以用到multiprocessing模块提供的Pool方法。初始化Pool时，可以指定一个最大进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到指定的最大值，那么该请求就会等待，直到池中有进程结束才会执行。需要注意的是，主进程不会主动等待进程池中的所有子进程结束后才结束，需要使用进程池的join()方法来堵塞主进程。
multiprocessing.Pool常用函数解析：
apply_async(func[, args[, kwds]]) ：使用非阻塞方式调用func（并行执行），args为传递给func的参数元组，kwds为传递给func的关键字参数字典；
apply(func[, args[, kwds]])：使用阻塞方式调用func，必须等待上一个进程退出才能执行下一个进程
close()：关闭Pool，使其不再接受新的任务；
terminate()：不管任务是否完成，立即终止；
join()：主进程阻塞，等待子进程的退出， 必须在close或terminate之后使用；
from multiprocessing import Poolimport os,time,randomdef worker(msg): t_start = time.time() print("%s开始执行,进程号为%d"%(msg,os.getpid())) #random.random()随机生成0~1之间的浮点数 time.sleep(random.random()*2) t_stop = time.time() print(msg,"执行完毕，耗时%0.2f"%(t_stop-t_start))po=Pool(3) #定义一个进程池，最大进程数3for i in range(0,10): #以非阻塞的方式向Po中添加任务 po.apply_async(worker,(i,))print("----start----")po.close() #关闭进程池，关闭后po不再接收新的请求po.join() #等待po中所有子进程执行完成，必须放在close语句之后print("-----end-----") 运行结果:
----start----0开始执行,进程号为287681开始执行,进程号为287692开始执行,进程号为287671 执行完毕，耗时0.663开始执行,进程号为287692 执行完毕，耗时1.354开始执行,进程号为287670 执行完毕，耗时1.495开始执行,进程号为287684 执行完毕，耗时0.155 执行完毕，耗时0.653 执行完毕，耗时1.76-----end-----
from multiprocessing import Poolimport os,time,randomdef worker(msg): t_start = time.time() print("%s开始执行,进程号为%d"%(msg,os.getpid())) #random.random()随机生成0~1之间的浮点数 time.sleep(random.random()*2) t_stop = time.time() print(msg,"执行完毕，耗时%0.2f"%(t_stop-t_start))po=Pool(3) #定义一个进程池，最大进程数3for i in range(6): #以阻塞的方式向Po中添加任务 po.apply(worker,(i,))print("----start----")po.close() #关闭进程池，关闭后po不再接收新的请求print("-----end-----") 运行结果：
0开始执行,进程号为287820 执行完毕，耗时0.931开始执行,进程号为287811 执行完毕，耗时1.252开始执行,进程号为287832 执行完毕，耗时0.533开始执行,进程号为287823 执行完毕，耗时0.274开始执行,进程号为287814 执行完毕，耗时0.935开始执行,进程号为287835 执行完毕，耗时1.69----start---------end-----
进程间是不共享数据（包括全局变量）的，但是可以使用multiprocessing模块的Queue实现多进程之间的数据传递，Queue本身是一个消息列队程序(先进先出)。初始化Queue()对象时（例如：q=Queue()），若括号中没有指定最大可接收的消息数量，或数量为负值，那么就代表可接受的消息数量没有上限（直到内存的尽头）。如果要使用Pool创建进程，就需要使用multiprocessing.Manager()中的Queue()，否则就会抛出异常。
Queue()对象常用方法:
# coding:utf-8from multiprocessing import Queueq = Queue(3) #创建一个消息队列，能容纳3条消息q.put('A')q.put('B')print(q.full()) #返回Falseq.put('C')print(q.full()) #返回Truetry: q.put('D',timeout=2) #堵塞等待2秒，后抛出异常except: print('消息队列已满，现有消息数量%d'%q.qsize())print(q.get()) #返回A，先进先出# 在写入消息的时候，先判断队列是否已满if not q.full(): q.put('D') print("还可以写入消息D")# 在取消息的时候，先判断队列是否为空if not q.empty(): for i in range(q.qsize()): print(q.get()) # coding:utf-8from multiprocessing import Process,Queuedef worker_write(q): '''负责写入''' if not q.full(): for i in range(10): q.put(i) print("写入数据%s"%i)def worker_read(q): '''负责读取''' if not q.empty(): for i in range(q.qsize()): print("读取数据%s"%q.get())def main(): q = Queue() #创建消息队列 p1 = Process(target=worker_write,args=(q,)) p2 = Process(target=worker_read,args=(q,)) p1.start() #开启写入子进程 p1.join() #等待写入子进程执行完毕 p2.start() #开启读取子进程 p2.join() #等待读取子进程执行完毕 print('所有数据都已写入并读取完毕')if __name__ == '__main__': main() # coding:utf-8from multiprocessing import Pool,Managerdef worker_write(q): '''负责写入''' if not q.full(): for i in range(10): q.put(i) print("写入数据%s"%i)def worker_read(q): '''负责读取''' if not q.empty(): for i in range(q.qsize()): print("读取数据%s"%q.get())def main(): q = Manager().Queue() #创建消息队列 po = Pool() po.apply(worker_write,args=(q,))# 使用堵塞的方式向Pool中添加任务 po.apply(worker_read,args=(q,)) po.close() print('写入数据并读取数据完毕')if __name__ == '__main__': main()
转载地址：http://niduz.baihongyu.com/